i2c_bridge-0.0.3/0000755000175500010010000000000010333143340011726 5ustar USERNonei2c_bridge-0.0.3/BUILD_ID0000644000175500010010000000007610333143340013067 0ustar USERNonei2c_bridge tag= ver=0.0.3 by USER Sat Nov 5 16:51:12 IST 2005 i2c_bridge-0.0.3/common/0000755000175500010010000000000010333143340013216 5ustar USERNonei2c_bridge-0.0.3/common/i2cbridge.h0000755000175500010010000002037710333135564015246 0ustar USERNone// Copyright (C)2004 Dimax ( http://www.xdimax.com ) // // This program is free software; you can redistribute it and/or // modify it under the terms of the GNU General Public License // as published by the Free Software Foundation // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. #ifndef I2C_BRIDGE_H_10DF0DED_E85F_4f14_88D9_610BEA2211F7 #define I2C_BRIDGE_H_10DF0DED_E85F_4f14_88D9_610BEA2211F7 #ifdef __linux__ /* * Compatibility stuff */ #include typedef int BOOL; #define TRUE 1 #define FALSE 0 typedef u_int8_t BYTE; typedef u_int8_t UCHAR; typedef u_int16_t WORD; typedef u_int32_t DWORD; typedef u_int32_t ULONG; typedef void* HANDLE; #define _stdcall /* nothing */ #define INVALID_HANDLE_VALUE ((HANDLE)(-1)) #endif #ifdef __GNUC__ #define __PACKED_ATTR __attribute__ ((__packed__)) #else #ifdef WIN32 #include #endif #define __PACKED_ATTR /*nothing*/ #pragma pack(push, 1) #endif typedef enum { U2C_SUCCESS = 0, /*!< API Function was successfull */ U2C_BAD_PARAMETER = 1, /*!< API Function got bad input parameter */ U2C_HARDWARE_NOT_FOUND = 2, /*!< U2C Device not found */ U2C_SLAVE_DEVICE_NOT_FOUND = 3, /*!< I2C Slave device not found */ U2C_TRANSACTION_FAILED = 4, /*!< I2C or SPI transaction failed */ U2C_SLAVE_OPENNING_FOR_WRITE_FAILED = 5, /*!< I2C Slave did not acknowledge write slave address */ U2C_SLAVE_OPENNING_FOR_READ_FAILED = 6, /*!< I2C Slave did not acknowledge read slave address */ U2C_SENDING_MEMORY_ADDRESS_FAILED = 7, /*!< I2C Slave did not acknowledge internal address output */ U2C_SENDING_DATA_FAILED = 8, /*!< I2C Slave did not acknowledge data output */ U2C_NOT_IMPLEMENTED = 9, /*!< Operation is not implemented by U2C API */ U2C_NO_ACK = 10, /*!< Got no ACK from Slave */ U2C_DEVICE_BUSY = 11, /*!< U2C Device Busy */ U2C_MEMORY_ERROR = 12, /*!< Memory operation (like malloc) failed */ U2C_UNKNOWN_ERROR = 13, /*!< Undocumented error */ U2C_I2C_CLOCK_SYNCH_TIMEOUT = 14, /*!< I2C Slave did not release SCL line */ } U2C_RESULT; /** * \brief I2C Transaction Descriptor * * This structure contains all required information to perform I2C transaction */ typedef struct _U2C_TRANSACTION { BYTE nSlaveDeviceAddress __PACKED_ATTR; /*!< I2C Slave device address in 7 bit format */ BYTE nMemoryAddressLength __PACKED_ATTR; /*!< Slave Device Internal address size */ DWORD nMemoryAddress __PACKED_ATTR; /*!< Slave Device Internal address (Memory address) */ WORD nBufferLength __PACKED_ATTR; /*!< Transaction buffer length. Can be from 1 up to 256 */ BYTE Buffer[256] __PACKED_ATTR; /*!< Transaction Buffer */ } U2C_TRANSACTION, *PU2C_TRANSACTION; /** * \brief I2C Transactions pack element */ typedef struct _U2C_TRANSACTION_PACK { BOOL rw; /*!< 1-Read 0-Write */ U2C_TRANSACTION tr; /*!< Transaction descriptor _U2C_TRANSACTION */ int rc; /*!< Transaction result */ } U2C_TRANSACTION_PACK, *PU2C_TRANSACTION_PACK; // I2C bus frequency values: #define U2C_I2C_FREQ_FAST 0 #define U2C_I2C_FREQ_STD 1 #define U2C_I2C_FREQ_83KHZ 2 #define U2C_I2C_FREQ_71KHZ 3 #define U2C_I2C_FREQ_62KHZ 4 #define U2C_I2C_FREQ_50KHZ 6 #define U2C_I2C_FREQ_25KHZ 16 #define U2C_I2C_FREQ_10KHZ 46 #define U2C_I2C_FREQ_5KHZ 96 #define U2C_I2C_FREQ_2KHZ 242 // SPI bus frequency values: #define U2C_SPI_FREQ_200KHZ 0 #define U2C_SPI_FREQ_100KHZ 1 #define U2C_SPI_FREQ_83KHZ 2 #define U2C_SPI_FREQ_71KHZ 3 #define U2C_SPI_FREQ_62KHZ 4 #define U2C_SPI_FREQ_50KHZ 6 #define U2C_SPI_FREQ_25KHZ 16 #define U2C_SPI_FREQ_10KHZ 46 #define U2C_SPI_FREQ_5KHZ 96 #define U2C_SPI_FREQ_2KHZ 242 typedef struct _U2C_SLAVE_ADDR_LIST { BYTE nDeviceNumber __PACKED_ATTR; BYTE List[256] __PACKED_ATTR; } U2C_SLAVE_ADDR_LIST, *PU2C_SLAVE_ADDR_LIST; typedef struct _U2C_VERSION_INFO { WORD MajorVersion __PACKED_ATTR; WORD MinorVersion __PACKED_ATTR; } U2C_VERSION_INFO, *PU2C_VERSION_INFO; typedef enum { LS_RELEASED, LS_DROPPED_BY_I2C_BRIDGE, LS_DROPPED_BY_SLAVE, LS_RAISED_BY_I2C_BRIDGE, } U2C_LINE_STATE; #ifdef __GNUC__ #undef __PACKED_ATTR #else #pragma pack(pop) #endif // I2CBridge Board Initialization Routines BYTE _stdcall U2C_GetDeviceCount(); U2C_RESULT _stdcall U2C_GetSerialNum(HANDLE hDevice, long* pSerialNum); U2C_RESULT _stdcall U2C_IsHandleValid(HANDLE hDevice); HANDLE _stdcall U2C_OpenDevice(BYTE nDevice); HANDLE _stdcall U2C_OpenDeviceBySerialNum(long nSerialNum); U2C_RESULT _stdcall U2C_CloseDevice(HANDLE hDevice); U2C_RESULT _stdcall U2C_GetFirmwareVersion(HANDLE hDevice, PU2C_VERSION_INFO pVersion); U2C_RESULT _stdcall U2C_GetDriverVersion(HANDLE hDevice, PU2C_VERSION_INFO pVersion); U2C_VERSION_INFO _stdcall U2C_GetDllVersion(); // I2C high level and configuration routines U2C_RESULT _stdcall U2C_SetI2cFreq(HANDLE hDevice, BYTE Frequency); U2C_RESULT _stdcall U2C_GetI2cFreq(HANDLE hDevice, BYTE *pFrequency); U2C_RESULT _stdcall U2C_SetClockSynch(HANDLE hDevice, BOOL Enable); U2C_RESULT _stdcall U2C_GetClockSynch(HANDLE hDevice, BOOL *pEnable); U2C_RESULT _stdcall U2C_Read(HANDLE hDevice, PU2C_TRANSACTION pTransaction); U2C_RESULT _stdcall U2C_Write(HANDLE hDevice, PU2C_TRANSACTION pTransaction); U2C_RESULT _stdcall U2C_RW_Pack(HANDLE hDevice, PU2C_TRANSACTION_PACK pTransaction, int count); U2C_RESULT _stdcall U2C_ScanDevices(HANDLE hDevice, PU2C_SLAVE_ADDR_LIST pList); // I2C low level routines U2C_RESULT _stdcall U2C_Start(HANDLE hDevice); U2C_RESULT _stdcall U2C_RepeatedStart(HANDLE hDevice); U2C_RESULT _stdcall U2C_Stop(HANDLE hDevice); U2C_RESULT _stdcall U2C_PutByte(HANDLE hDevice, BYTE Data); U2C_RESULT _stdcall U2C_GetByte(HANDLE hDevice, BYTE *pData); U2C_RESULT _stdcall U2C_PutByteWithAck(HANDLE hDevice, BYTE Data); U2C_RESULT _stdcall U2C_GetByteWithAck(HANDLE hDevice, BYTE *pData, BOOL bAck); U2C_RESULT _stdcall U2C_PutAck(HANDLE hDevice, BOOL bAck); U2C_RESULT _stdcall U2C_GetAck(HANDLE hDevice); // I2c wire level routines U2C_RESULT _stdcall U2C_ReadScl(HANDLE hDevice, U2C_LINE_STATE *pState); U2C_RESULT _stdcall U2C_ReadSda(HANDLE hDevice, U2C_LINE_STATE *pState); U2C_RESULT _stdcall U2C_ReleaseScl(HANDLE hDevice); U2C_RESULT _stdcall U2C_ReleaseSda(HANDLE hDevice); U2C_RESULT _stdcall U2C_DropScl(HANDLE hDevice); U2C_RESULT _stdcall U2C_DropSda(HANDLE hDevice); // GPIO routines U2C_RESULT _stdcall U2C_SetIoDirection(HANDLE hDevice, ULONG Value, ULONG Mask); U2C_RESULT _stdcall U2C_GetIoDirection(HANDLE hDevice, ULONG *pValue); U2C_RESULT _stdcall U2C_IoWrite(HANDLE hDevice, ULONG Value, ULONG Mask); U2C_RESULT _stdcall U2C_IoRead(HANDLE hDevice, ULONG *pValue); U2C_RESULT _stdcall U2C_SetSingleIoDirection(HANDLE hDevice, ULONG IoNumber, BOOL bOutput); U2C_RESULT _stdcall U2C_GetSingleIoDirection(HANDLE hDevice, ULONG IoNumber, BOOL *pbOutput); U2C_RESULT _stdcall U2C_SingleIoWrite(HANDLE hDevice, ULONG IoNumber, BOOL Value); U2C_RESULT _stdcall U2C_SingleIoRead(HANDLE hDevice, ULONG IoNumber, BOOL *pValue); // SPI configuration routines U2C_RESULT _stdcall U2C_SpiSetConfig(HANDLE hDevice, BYTE CPOL, BYTE CPHA); U2C_RESULT _stdcall U2C_SpiGetConfig(HANDLE hDevice, BYTE *pCPOL, BYTE *pCPHA); U2C_RESULT _stdcall U2C_SpiSetConfigEx(HANDLE hDevice, DWORD Config); U2C_RESULT _stdcall U2C_SpiGetConfigEx(HANDLE hDevice, DWORD *pConfig); U2C_RESULT _stdcall U2C_SpiSetFreq(HANDLE hDevice, BYTE Frequency); U2C_RESULT _stdcall U2C_SpiGetFreq(HANDLE hDevice, BYTE *pFrequency); U2C_RESULT _stdcall U2C_SpiReadWrite(HANDLE hDevice, BYTE *pOutBuffer, BYTE *pInBuffer, WORD Length); U2C_RESULT _stdcall U2C_SpiWrite(HANDLE hDevice, BYTE *pOutBuffer, WORD Length); U2C_RESULT _stdcall U2C_SpiRead(HANDLE hDevice, BYTE *pInBuffer, WORD Length); #endif //I2C_BRIDGE_H_10DF0DED_E85F_4f14_88D9_610BEA2211F7 i2c_bridge-0.0.3/u2c/0000755000175500010010000000000010333143340012417 5ustar USERNonei2c_bridge-0.0.3/u2c/dev_rout.c0000755000175500010010000002274710213345573014442 0ustar USERNone/* Copyright (C)2004 Dimax ( http://www.xdimax.com ) This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. */ /* *------------------------------------------------------------------- * Description: i2cbrdg main device routines module *------------------------------------------------------------------- * Version: $Id: dev_rout.c,v 1.1 2005/03/08 15:57:47 dmitry_kulik Exp $ *------------------------------------------------------------------- */ #include #include #include #include #include //#include "i2cbridge.h" #include "dev_rout.h" //----------------------------------------------------------------------------- // Constants //----------------------------------------------------------------------------- #define DIMAX_VENDOR 0x0abf #define DIMAX_PRODUCT 0x3370 #define DIMAX_IF 0x00 #define DIMAX_IN_EP 0x84 #define DIMAX_OUT_EP 0x02 #define DIMAX_TIMEOUT 100 // ms int debug=0; //----------------------------------------------------------------------------- // Global Variables //----------------------------------------------------------------------------- static int usb_init_done; //----------------------------------------------------------------------------- // Local Function Definition //----------------------------------------------------------------------------- static U2C_RESULT u2c_libusb_rc( int rc ); BYTE dr_get_device_count( void ) { BYTE dev_count=0; struct usb_bus *bus; struct usb_device *dev; if( ! usb_init_done ) { usb_init(); usb_init_done=1; } usb_find_busses(); usb_find_devices(); bus=usb_get_busses(); for( ; bus; bus=bus->next ) for( dev=bus->devices; dev; dev=dev->next ) { if ( dev->descriptor.idVendor == DIMAX_VENDOR && dev->descriptor.idProduct == DIMAX_PRODUCT ) { dev_count++; } } return dev_count; } HANDLE dr_open_device(BYTE nDevice) { BYTE devc=0; int found=0; struct usb_bus *bus; struct usb_device *dev=0; HANDLE hDevice; if( ! usb_init_done ) { usb_init(); usb_init_done=1; } usb_find_busses(); usb_find_devices(); bus=usb_get_busses(); while(bus && !found) { for( dev=bus->devices; dev; dev=dev->next ) { if ( dev->descriptor.idVendor == DIMAX_VENDOR && dev->descriptor.idProduct == DIMAX_PRODUCT ) { if( devc == nDevice ) { found = 1; break; } devc++; } } bus = bus->next; } if( ! dev ) return INVALID_HANDLE_VALUE; /* * Open device file * You should have sufficient permisions to do that */ hDevice = usb_open(dev); if( ! hDevice ) return INVALID_HANDLE_VALUE; return hDevice; } U2C_RESULT dr_close_device(HANDLE hDevice) { usb_close( hDevice ); return U2C_SUCCESS; } U2C_RESULT dr_is_handle_valid(HANDLE hDevice) { if( hDevice ) return U2C_SUCCESS; else return U2C_HARDWARE_NOT_FOUND; } U2C_RESULT dr_get_driver_version(HANDLE hDevice, PU2C_VERSION_INFO pVersion) { return U2C_NOT_IMPLEMENTED; } //----------------------------------------------------------------------------- // Local Functions //----------------------------------------------------------------------------- /* * Convert errno codes returned by libusb to U2C_RESULT */ static U2C_RESULT u2c_libusb_rc( int rc ) { if( rc ) switch( rc ) { case EBUSY: return U2C_DEVICE_BUSY; case ENOMEM: return U2C_MEMORY_ERROR; default: return U2C_UNKNOWN_ERROR; } else return U2C_SUCCESS; } /* * Convert FW status codes to U2C_RESULT */ U2C_RESULT u2c_fw_rc( int rc ) { if( rc ) switch( rc ) { case 1: return U2C_TRANSACTION_FAILED; case 2: return U2C_SLAVE_OPENNING_FOR_WRITE_FAILED; case 3: return U2C_SLAVE_OPENNING_FOR_READ_FAILED; case 4: return U2C_SENDING_MEMORY_ADDRESS_FAILED; case 5: return U2C_SENDING_DATA_FAILED; case 6: return U2C_NOT_IMPLEMENTED; case 7: return U2C_NO_ACK; default: return U2C_UNKNOWN_ERROR; } else return U2C_SUCCESS; } /* * Dump buffer */ static void dump_buf( char* title, char* buf, int size ) { int i; if( title ) printf( title ); for( i=0; iOutputBuffer, req->OutputBufferLength ); rc = usb_bulk_write( hDevice, DIMAX_OUT_EP, req->OutputBuffer, req->OutputBufferLength, DIMAX_TIMEOUT ); if( rc != req->OutputBufferLength ) { if( debug ) printf( "usb_bulk_write failed rc=%d\n", rc ); rc = U2C_TRANSACTION_FAILED; goto cleanup; } /* Bulk in */ rc = usb_bulk_read( hDevice, DIMAX_IN_EP, req->InputBuffer, MAX_INPUT_BUFFER_LENGTH, DIMAX_TIMEOUT ); if (req->InputBufferLength == 0) req->InputBufferLength = rc; if(( rc != req->InputBufferLength ) || (rc == 0)) { if( debug ) printf( "usb_bulk_read failed rc=%d\n", rc ); rc = U2C_TRANSACTION_FAILED; goto cleanup; } if( debug ) dump_buf( "Bulk In: ", req->InputBuffer, req->InputBufferLength ); /* Check Status. Status is returned by fw in last byte */ if( req->InputBuffer[req->InputBufferLength-1] ) rc = u2c_fw_rc( req->InputBuffer[req->InputBufferLength-1] ); else rc = U2C_SUCCESS; cleanup: /* Unblock signals which was not blocked */ for( i=0; i 128 ) return U2C_BAD_PARAMETER; memcpy( out_buf+offs, req[i].OutputBuffer, req[i].OutputBufferLength ); offs += req[i].OutputBufferLength; } /* Send request */ rc = usb_bulk_write( hDevice, DIMAX_OUT_EP, out_buf, offs, DIMAX_TIMEOUT ); if( rc != offs ) { if( debug ) printf( "usb_bulk_write pack failed rc=%d\n", rc ); rc = U2C_TRANSACTION_FAILED; goto cleanup; } /* * Bulk in */ for( i=0; i 0 ) memcpy( req[i].InputBuffer, in_buf, rc ); } rc=0; cleanup: /* Unblock signals which was not blocked */ for( i=0; i #else #include "stdafx.h" #include ".\I2C.h" #endif CI2c::CI2c(void) { } CI2c::~CI2c(void) { } bool CI2c::OpenDevice() { BYTE DevCount = U2C_GetDeviceCount(); if (DevCount == 0) { m_Res = U2C_HARDWARE_NOT_FOUND; return false; } m_hDevice = U2C_OpenDevice(0); if (m_hDevice == INVALID_HANDLE_VALUE) { m_Res = U2C_HARDWARE_NOT_FOUND; return false; } return true; } void CI2c::CloseDevice() { U2C_CloseDevice(m_hDevice); m_hDevice = INVALID_HANDLE_VALUE; } bool CI2c::Read(PU2C_TRANSACTION pTransaction) { if (!OpenDevice()) return false; m_Res = U2C_Read(m_hDevice, pTransaction); CloseDevice(); return m_Res == U2C_SUCCESS; } bool CI2c::Write(PU2C_TRANSACTION pTransaction) { if (!OpenDevice()) return false; m_Res = U2C_Write(m_hDevice, pTransaction); CloseDevice(); return m_Res == U2C_SUCCESS; } void CI2c::PrintError() { #ifdef __linux__ char* results[]= #else std::string results[] = #endif { "U2C_SUCCESS", "U2C_BAD_PARAMETER", "U2C_HARDWARE_NOT_FOUND", "U2C_SLAVE_DEVICE_NOT_FOUND", "U2C_TRANSACTION_FAILED", "U2C_SLAVE_OPENNING_FOR_WRITE_FAILED", "U2C_SLAVE_OPENNING_FOR_READ_FAILED", "U2C_SENDING_MEMORY_ADDRESS_FAILED", "U2C_SENDING_DATA_FAILED", "U2C_NOT_IMPLEMENTED", "U2C_NO_ACK", "U2C_UNKNOWN_ERROR", }; std::cout << "I2C error: " << results[m_Res] << std::endl; } i2c_bridge-0.0.3/u2c/i2c/I2c.h0000755000175500010010000000157110213346621013675 0ustar USERNone// Copyright (C)2004 Dimax ( http://www.xdimax.com ) // // This program is free software; you can redistribute it and/or // modify it under the terms of the GNU General Public License // as published by the Free Software Foundation // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. #ifdef __linux__ extern "C" { #include } #else #pragma once #include "../common/I2CBridge.h" #endif class CI2c { public: CI2c(void); virtual ~CI2c(void); bool Read(PU2C_TRANSACTION pTransaction); bool Write(PU2C_TRANSACTION pTransaction); void PrintError(); private: U2C_RESULT m_Res; bool OpenDevice(); void CloseDevice(); HANDLE m_hDevice; }; i2c_bridge-0.0.3/u2c/i2c/main.cpp0000755000175500010010000001113010213346622014530 0ustar USERNone// Copyright (C)2004 Dimax ( http://www.xdimax.com ) // // This program is free software; you can redistribute it and/or // modify it under the terms of the GNU General Public License // as published by the Free Software Foundation // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. #ifdef __linux__ #include "i2cbridge.h" #include #include #else #include "stdafx.h" #include "../common/I2CBridge.h" #endif #include "I2c.h" #include "Parser.h" void PrintUsage() { std::cout << "I2C command -s:slave_addr [-a:addr_length:address] [-d:data_length] [data]\n"; std::cout << "I2C -h\n"; std::cout << "\n\n"; std::cout << " command Specifies the command to be executed. Possible values are:\n"; std::cout << " \"r[ead]\" or \"w[rite]\".\n"; std::cout << " -h Prints this help message.\n"; std::cout << " -s:slave_addr Specifies the I2C slave device address.\n"; std::cout << " -a:addr_length:address\n"; std::cout << " Specifies the length of the slave memory address in bytes\n"; std::cout << " and the slave memory address itself. Possible values for\n"; std::cout << " address length are: 0, 1, 2 or 4. If 0 is provided as\n"; std::cout << " address length, addr parameter have to be omitted.\n"; std::cout << " Default value is 0.\n"; std::cout << " -d:data_length Specifies the length of the data in bytes (decimal value).\n"; std::cout << " For write command data_length can be omitted - it will be\n"; std::cout << " calculated from the data passed. If data_length is\n"; std::cout << " provided for write command it will be compared with \n"; std::cout << " the actual data length and user will be warned in case of\n"; std::cout << " inconsistence.\n"; std::cout << " For read command data_length is obligatory.\n"; std::cout << " data Specifies the data to be sent to device.\n"; std::cout << " For read command data will be omitted.\n"; std::cout << std::endl; std::cout << " slave_addr, addr_length, address and data_length have to be provided in\n"; std::cout << " the following format: [0[x]][digits].\n"; std::cout << " If the first character is '0' and the second character is not 'x',\n"; std::cout << " the string is interpreted as an octal integer.\n"; std::cout << " If the first two characters are \"0x\", the string is interpreted\n"; std::cout << " as a hexadecimal integer.\n"; std::cout << " If the first character is '1' through '9', the string is interpreted\n"; std::cout << " as a decimal integer.\n"; std::cout << " data has to be provided as hex string with single bytes separated by space\n"; std::cout << std::endl; } void PrintError(CParser::result res) { if (res == CParser::rHelpRequested) { PrintUsage(); return; } #ifdef __linux__ char* tmp_results[]= #else std::string tmp_results[] = #endif { "rSuccess", "rHelprequested", "rBadParameter", "rInvalidCommand", "rInvalidSlaveDeviceAddress", "rAbsentSlaveDeviceAddress", "rInvalidMemoryAddressLength", "rDuplicatedMemoryAddressLengthLength", "rAbsentMemoryAddressLength", "rInvalidMemoryAddress", "rAbsentMemoryAddress", "rInvalidDataLength", "rDuplicatedDataLength", "rAbsentDataLength", "rInvalidData", "rDataLengthMismatch", "rAbsentData", "rDataInreadCommand" }; std::cout << "Parsing error: " << tmp_results[res] << std::endl; } int main(int argc, char* argv[]) { U2C_TRANSACTION Transaction; CParser Parser; CParser::result res; unsigned short i; res = Parser.ParseArguments(argc, argv); if (res != CParser::rSuccess) { PrintError(res); return res; } res = Parser.FillTransaction(&Transaction); if (res != CParser::rSuccess) { PrintError(res); return res; } CI2c I2C; if (Parser.GetCommand() == CParser::cRead) { if (I2C.Read(&Transaction)) { for( i = 0; i < Transaction.nBufferLength; i++) { printf("%02x ", Transaction.Buffer[i]); if (i%16 == 15) printf("\n"); } if (i%16 != 0) printf("\n"); } else I2C.PrintError(); } else { if (!I2C.Write(&Transaction)) I2C.PrintError(); } return res; } i2c_bridge-0.0.3/u2c/i2c/Makefile0000755000175500010010000000100610333142665014545 0ustar USERNoneall: i2c INC_DIR += -I../../common LIB_DIR += -L../ LIB += -li2cbrdg CC = $(CROSS_COMPILE)gcc LD = $(CROSS_COMPILE)ld AR = $(CROSS_COMPILE)ar CPP = $(CROSS_COMPILE)g++ ### Regular builds CFLAGS += -MD -g -O2 -Wall -Werror -Wno-deprecated -I. ${INC_DIR} LDFLAGS += ${LIB} ${LIB_DIR} %.o: %.c $(CC) $(CFLAGS) -c -o $@ $< %.o: %.cpp $(CPP) -c $(CFLAGS) -o $@ $< clean: rm -f *.o *.d i2c ### Target builds I2C_OBJ = I2c.o Parser.o main.o i2c : $(I2C_OBJ) $(CPP) -o $@ $(LDFLAGS) $(I2C_OBJ) i2c_bridge-0.0.3/u2c/i2c/Parser.cpp0000755000175500010010000001543410213346621015052 0ustar USERNone// Copyright (C)2004 Dimax ( http://www.xdimax.com ) // // This program is free software; you can redistribute it and/or // modify it under the terms of the GNU General Public License // as published by the Free Software Foundation // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. #ifdef __linux__ #include #include #include #include #include #else #include "stdafx.h" #endif #include "Parser.h" ////////////////////////////////////////////////////////////////////// // Construction/Destruction ////////////////////////////////////////////////////////////////////// CParser::CParser(): m_bDataLengthInited(false), m_nMemoryAddressLength(1), m_bMemoryAddressLengthInited(false), m_bSlaveDeviceAddressInited(false), m_bMemoryAddressInited(false), m_nCurrData(0), m_State(command_expected) { } CParser::~CParser() { } CParser::result CParser::ParseArguments(int argc, char* argv[]) { result rValue=rBadParameter; if (argc < 2) return rHelpRequested; for (int i=1; i 256)) return rInvalidDataLength; m_nDataLength = (unsigned short) DataLen; m_bDataLengthInited = true; return rSuccess; } CParser::result CParser::ParseMemoryAddressLength(char* strAddr) { if (m_bMemoryAddressLengthInited) return rDuplicatedMemoryAddressLengthLength; if (*strAddr == 0) return rInvalidMemoryAddressLength; unsigned long AddrLen; char *endp; AddrLen = strtoul(strAddr, &endp, 0); if (*endp!=':') return rInvalidMemoryAddressLength; if ((AddrLen != 0) && (AddrLen != 1) && (AddrLen != 2) && (AddrLen != 4)) return rInvalidMemoryAddressLength; m_nMemoryAddressLength = (BYTE)AddrLen; m_bMemoryAddressLengthInited = true; strAddr = endp + 1; return ParseMemoryAddress(strAddr); } CParser::result CParser::ParseCommand(char* strCommand) { switch (*strCommand) { case 'r': case 'R': m_Command = cRead; break; case 'w': case 'W': m_Command = cWrite; break; default: return rInvalidCommand; } m_State = data_expected; return rSuccess; } CParser::result CParser::ParseSlaveDeviceAddress(char* strSlaveAddr) { char *endp; unsigned long SlaveAddr; SlaveAddr = strtoul(strSlaveAddr, &endp, 0); if ((*endp) || (SlaveAddr > 0xFF)) return rInvalidSlaveDeviceAddress; m_nSlaveDeviceAddress = (BYTE)SlaveAddr; m_bSlaveDeviceAddressInited = true; return rSuccess; } CParser::result CParser::ParseMemoryAddress(char* strAddr) { char *endp; errno = 0; if (*strAddr == 0) return rInvalidMemoryAddress; m_nMemoryAddress = strtoul(strAddr, &endp, 0); if ((*endp) || (errno != 0)) return rInvalidMemoryAddress; if (((m_nMemoryAddressLength == 1) && (m_nMemoryAddress > 0xFF)) || ((m_nMemoryAddressLength == 2) && (m_nMemoryAddress > 0xFFFF)) ) return rInvalidMemoryAddress; m_bMemoryAddressInited = true; return rSuccess; } CParser::result CParser::ParseData(char* strData) { if (m_nCurrData == MAX_DATA_LEN) return rDataLengthMismatch; char *endp; errno = 0; if (*strData == 0) return rInvalidData; unsigned long Data = strtoul(strData, &endp, 16); if ((*endp) || (errno !=0) || (Data > 0xFF)) return rInvalidData; m_DataBuffer[m_nCurrData] = (BYTE) Data; m_nCurrData++; return rSuccess; } CParser::result CParser::FillTransaction(PU2C_TRANSACTION pRequest) { #ifdef __linux__ memset( pRequest, 0x00, sizeof(U2C_TRANSACTION) ); #else ZeroMemory(pRequest, sizeof(U2C_TRANSACTION)); #endif result rValue; if (rSuccess != (rValue = FillSlaveDeviceAddress(pRequest))) return rValue; if (rSuccess != (rValue = FillMemoryAddressLength(pRequest))) return rValue; if (rSuccess != (rValue = FillMemoryAddress(pRequest))) return rValue; if (rSuccess != (rValue = CheckBuffer())) return rValue; if (rSuccess != (rValue = FillBuffer(pRequest))) return rValue; return rSuccess; } CParser::result CParser::FillSlaveDeviceAddress(PU2C_TRANSACTION pTransaction) { if (!m_bSlaveDeviceAddressInited) return rAbsentSlaveDeviceAddress; pTransaction->nSlaveDeviceAddress = m_nSlaveDeviceAddress; return rSuccess; } CParser::result CParser::FillMemoryAddressLength(PU2C_TRANSACTION pTransaction) { // if (!m_bMemoryAddressLengthInited) // return rAbsentMemoryAddressLength; pTransaction->nMemoryAddressLength = m_nMemoryAddressLength; return rSuccess; } CParser::result CParser::FillMemoryAddress(PU2C_TRANSACTION pTransaction) { pTransaction->nMemoryAddress = m_nMemoryAddress; return rSuccess; } CParser::result CParser::CheckBuffer() { switch(m_Command) { case cRead: if (!m_bDataLengthInited) return rAbsentDataLength; if (m_nCurrData != 0) return rDataInReadCommand; break; case cWrite: if ((m_bDataLengthInited) && (m_nDataLength != m_nCurrData)) return rDataLengthMismatch; if (m_nCurrData == 0) return rAbsentData; break; default: return rInvalidCommand; } return rSuccess; } CParser::result CParser::FillBuffer(PU2C_TRANSACTION pTransaction) { switch (m_Command) { case cRead: pTransaction->nBufferLength = m_nDataLength; break; case cWrite: pTransaction->nBufferLength = m_nCurrData; break; default: return rInvalidCommand; } #ifdef __linux__ memcpy( pTransaction->Buffer, m_DataBuffer, m_nCurrData ); #else CopyMemory(pTransaction->Buffer, m_DataBuffer, m_nCurrData); #endif return rSuccess; } i2c_bridge-0.0.3/u2c/i2c/Parser.h0000755000175500010010000000521010213346621014506 0ustar USERNone// Copyright (C)2004 Dimax ( http://www.xdimax.com ) // // This program is free software; you can redistribute it and/or // modify it under the terms of the GNU General Public License // as published by the Free Software Foundation // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. #if !defined(AFX_PARSER_H__A9227E4D_DCF5_4F24_BA7E_3C34301D83DD__INCLUDED_) #define AFX_PARSER_H__A9227E4D_DCF5_4F24_BA7E_3C34301D83DD__INCLUDED_ #ifdef __linux__ #else #if _MSC_VER > 1000 #pragma once #endif // _MSC_VER > 1000 #endif #define MAX_DATA_LEN 256 class CParser { public: enum result { rSuccess, rHelpRequested, rBadParameter, rInvalidCommand, // read or write expected rInvalidSlaveDeviceAddress, rAbsentSlaveDeviceAddress, rInvalidMemoryAddressLength, rDuplicatedMemoryAddressLengthLength, rAbsentMemoryAddressLength, rInvalidMemoryAddress, rAbsentMemoryAddress, rInvalidDataLength, rDuplicatedDataLength, rAbsentDataLength, rInvalidData, rDataLengthMismatch, rAbsentData, rDataInReadCommand // have been found redundant data in read command }; enum command { cRead, cWrite }; command GetCommand() {return m_Command;}; CParser(); virtual ~CParser(); result FillTransaction(PU2C_TRANSACTION pRequest); result ParseArguments(int argc, char* argv[]); private: // PU2C_TRANSACTION m_pRequest; unsigned short m_nDataLength; bool m_bDataLengthInited; BYTE m_nMemoryAddressLength; bool m_bMemoryAddressLengthInited; BYTE m_nSlaveDeviceAddress; bool m_bSlaveDeviceAddressInited; DWORD m_nMemoryAddress; bool m_bMemoryAddressInited; command m_Command; BYTE m_DataBuffer[MAX_DATA_LEN]; int m_nCurrData; typedef enum { command_expected, data_expected, } m_State_t; m_State_t m_State; result ParseDataLength(char* strDataLen); result ParseMemoryAddressLength(char* strAddrLen); result ParseCommand(char* strCommand); result ParseData(char* strData); result ParseSlaveDeviceAddress(char* strSlaveAddr); result ParseMemoryAddress(char* strAddr); result FillSlaveDeviceAddress(PU2C_TRANSACTION pTransaction); result FillMemoryAddressLength(PU2C_TRANSACTION pTransaction); result FillMemoryAddress(PU2C_TRANSACTION pTransaction); result CheckBuffer(); result FillBuffer(PU2C_TRANSACTION pTransaction); }; #endif // !defined(AFX_PARSER_H__A9227E4D_DCF5_4F24_BA7E_3C34301D83DD__INCLUDED_) i2c_bridge-0.0.3/u2c/i2cbridge.c0000755000175500010010000004642510333135316014437 0ustar USERNone /* Copyright (C)2004 Dimax ( http://www.xdimax.com ) This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. */ /* *------------------------------------------------------------------- * Description: i2cbrdg main module *------------------------------------------------------------------- * Version: $Id: i2cbridge.c,v 1.2 2005/11/05 13:59:42 xol Exp $ *------------------------------------------------------------------- */ #ifdef WIN32 #include #endif #include #include "string.h" #include "../common/i2cbridge.h" #include "dev_rout.h" #define maj_ver 0 #define min_ver 5 //----------------------------------------------------------------------------- // Open/Close Functions //----------------------------------------------------------------------------- BYTE _stdcall U2C_GetDeviceCount( void ) { return dr_get_device_count(); } HANDLE _stdcall U2C_OpenDevice(BYTE nDevice) { return dr_open_device(nDevice); } U2C_RESULT _stdcall U2C_CloseDevice(HANDLE hDevice) { return dr_close_device(hDevice); } U2C_RESULT _stdcall U2C_IsHandleValid(HANDLE hDevice) { return dr_is_handle_valid(hDevice); } U2C_RESULT _stdcall U2C_GetSerialNum(HANDLE hDevice, long* pSerialNum) { U2C_RESULT rc; DEVICE_REQUEST req; req.OutputBufferLength = 1; req.OutputBuffer[0] = 0x0B; req.InputBufferLength = 5; rc = dr_u2c_transaction( hDevice, &req ); memcpy(pSerialNum, req.InputBuffer, 4); return rc; } U2C_RESULT _stdcall U2C_GetFirmwareVersion(HANDLE hDevice, PU2C_VERSION_INFO pVersion) { U2C_RESULT rc; DEVICE_REQUEST req; req.OutputBufferLength = 1; req.OutputBuffer[0] = 0x0A; req.InputBufferLength = 3; rc = dr_u2c_transaction( hDevice, &req ); pVersion->MajorVersion = req.InputBuffer[0]; pVersion->MinorVersion = req.InputBuffer[1]; return rc; } HANDLE _stdcall U2C_OpenDeviceBySerialNum(long nSerialNum) { BYTE dev_num, i; HANDLE dev; long sn; dev_num = U2C_GetDeviceCount(); for (i = 0; i < dev_num; i++) { dev = U2C_OpenDevice(i); if ((dev != INVALID_HANDLE_VALUE) && (U2C_SUCCESS == U2C_GetSerialNum(dev, &sn)) && (sn == nSerialNum)) { return dev; } U2C_CloseDevice(dev); } return INVALID_HANDLE_VALUE; } U2C_VERSION_INFO _stdcall U2C_GetDllVersion() { U2C_VERSION_INFO ver; ver.MajorVersion = maj_ver; ver.MinorVersion = min_ver; return ver; } U2C_RESULT _stdcall U2C_GetDriverVersion(HANDLE hDevice, PU2C_VERSION_INFO pVersion) { return dr_get_driver_version(hDevice, pVersion); } //----------------------------------------------------------------------------- // I2C high level and configuration routines //----------------------------------------------------------------------------- // Convert I2C Transaction into U2C device request static U2C_RESULT _stdcall u2c_prep_i2c_req( PU2C_TRANSACTION pTransaction, PDEVICE_REQUEST preq, BOOL rw ) { int i=0; if (pTransaction->nSlaveDeviceAddress > 0x7F) return U2C_BAD_PARAMETER; if( rw ) preq->OutputBuffer[i++] = 0x01; // Read request else preq->OutputBuffer[i++] = 0x02; // Write request // Memory address size preq->OutputBuffer[i++] = pTransaction->nMemoryAddressLength; // Write slave address if( !rw || pTransaction->nMemoryAddressLength ) preq->OutputBuffer[i++] = (pTransaction->nSlaveDeviceAddress<<1) & 0xFE; // Memory Address. LSB first if( pTransaction->nMemoryAddressLength == 4 ) { preq->OutputBuffer[i++] = (UCHAR)((pTransaction->nMemoryAddress>>24) & 0xFF); preq->OutputBuffer[i++] = (UCHAR)((pTransaction->nMemoryAddress>>16) & 0xFF); } if( pTransaction->nMemoryAddressLength >= 2 ) preq->OutputBuffer[i++] = (UCHAR)((pTransaction->nMemoryAddress>>8) & 0xFF); if( pTransaction->nMemoryAddressLength >= 1 ) preq->OutputBuffer[i++] = (UCHAR)(pTransaction->nMemoryAddress & 0xFF); // Read Slave address if( rw ) preq->OutputBuffer[i++] = (pTransaction->nSlaveDeviceAddress<<1) | 0x01; // Data size if ((pTransaction->nBufferLength > 256) || (pTransaction->nBufferLength == 0)) return U2C_BAD_PARAMETER; if (pTransaction->nBufferLength == 256) preq->OutputBuffer[i++] = 0; else preq->OutputBuffer[i++] = (UCHAR)pTransaction->nBufferLength; // Data to write if( !rw ) { memcpy( &preq->OutputBuffer[i], pTransaction->Buffer, pTransaction->nBufferLength ); i+= pTransaction->nBufferLength; } preq->OutputBufferLength = i; if( rw ) preq->InputBufferLength = pTransaction->nBufferLength+1; else preq->InputBufferLength = 1; return U2C_SUCCESS; } U2C_RESULT _stdcall U2C_Read(HANDLE hDevice, PU2C_TRANSACTION pTransaction) { U2C_RESULT rc; DEVICE_REQUEST req; rc = u2c_prep_i2c_req( pTransaction, &req, 1 ); if( U2C_SUCCESS != rc ) return rc; rc = dr_u2c_transaction( hDevice, &req ); if( rc ) return rc; memcpy(pTransaction->Buffer, req.InputBuffer, pTransaction->nBufferLength); return rc; } U2C_RESULT _stdcall U2C_Write(HANDLE hDevice, PU2C_TRANSACTION pTransaction) { U2C_RESULT rc; DEVICE_REQUEST req; rc = u2c_prep_i2c_req( pTransaction, &req, 0 ); if( U2C_SUCCESS != rc ) return rc; return dr_u2c_transaction( hDevice, &req ); } #ifdef __linux__ U2C_RESULT _stdcall U2C_RW_Pack(HANDLE hDevice, PU2C_TRANSACTION_PACK pTransaction, int count) { U2C_RESULT rc; PDEVICE_REQUEST preq; int i; preq = malloc( count * sizeof(DEVICE_REQUEST) ); // Prepare request pack for( i=0; inDeviceNumber = 0; req.OutputBufferLength = 1; req.OutputBuffer[0] = 0x3; req.InputBufferLength = 0; if (U2C_SUCCESS != (rc = dr_u2c_transaction(hDevice, &req))) return rc; for (i = 0; i < req.InputBufferLength - 1; i++) pList->List[i] = (req.InputBuffer[i] >> 1); pList->nDeviceNumber = (BYTE)(req.InputBufferLength - 1); return rc; } //----------------------------------------------------------------------------- // I2C low level routines //----------------------------------------------------------------------------- U2C_RESULT _stdcall U2C_Start(HANDLE hDevice) { DEVICE_REQUEST req; req.OutputBufferLength = 1; req.OutputBuffer[0] = 0x0C; req.InputBufferLength = 1; return dr_u2c_transaction(hDevice, &req); } U2C_RESULT _stdcall U2C_RepeatedStart(HANDLE hDevice) { DEVICE_REQUEST req; req.OutputBufferLength = 1; req.OutputBuffer[0] = 0x0E; req.InputBufferLength= 1; return dr_u2c_transaction(hDevice, &req); } U2C_RESULT _stdcall U2C_Stop(HANDLE hDevice) { DEVICE_REQUEST req; req.OutputBufferLength = 1; req.OutputBuffer[0] = 0x0D; req.InputBufferLength = 1; return dr_u2c_transaction(hDevice, &req); } U2C_RESULT _stdcall U2C_PutByte(HANDLE hDevice, BYTE Data) { DEVICE_REQUEST req; req.OutputBufferLength = 2; req.OutputBuffer[0] = 0x0F; req.OutputBuffer[1] = Data; req.InputBufferLength = 1; return dr_u2c_transaction(hDevice, &req); } U2C_RESULT _stdcall U2C_GetByte(HANDLE hDevice, BYTE *pData) { U2C_RESULT rc; DEVICE_REQUEST req; req.OutputBufferLength = 1; req.OutputBuffer[0] = 0x10; req.InputBufferLength = 2; rc = dr_u2c_transaction(hDevice, &req); *pData = req.InputBuffer[0]; return rc; } U2C_RESULT _stdcall U2C_PutByteWithAck(HANDLE hDevice, BYTE Data) { DEVICE_REQUEST req; req.OutputBufferLength = 2; req.OutputBuffer[0] = 0x13; req.OutputBuffer[1] = Data; req.InputBufferLength = 1; return dr_u2c_transaction(hDevice, &req); } U2C_RESULT _stdcall U2C_GetByteWithAck(HANDLE hDevice, BYTE *pData, BOOL bAck) { U2C_RESULT rc; DEVICE_REQUEST req; req.OutputBufferLength = 2; req.OutputBuffer[0] = 0x14; req.OutputBuffer[1] = (UCHAR)bAck; req.InputBufferLength = 2; rc = dr_u2c_transaction(hDevice, &req); *pData = req.InputBuffer[0]; return rc; } U2C_RESULT _stdcall U2C_PutAck(HANDLE hDevice, BOOL bAck) { DEVICE_REQUEST req; req.OutputBufferLength = 2; req.OutputBuffer[0] = 0x11; req.OutputBuffer[1] = (UCHAR)bAck; req.InputBufferLength = 1; return dr_u2c_transaction(hDevice, &req); } U2C_RESULT _stdcall U2C_GetAck(HANDLE hDevice) { DEVICE_REQUEST req; req.OutputBufferLength = 1; req.OutputBuffer[0] = 0x12; req.InputBufferLength = 1; return dr_u2c_transaction(hDevice, &req); } //----------------------------------------------------------------------------- // I2C wire level routines //----------------------------------------------------------------------------- static U2C_RESULT read_line_state(HANDLE hDevice, U2C_LINE_STATE *pState, BYTE command) { U2C_RESULT rc; DEVICE_REQUEST req; req.OutputBufferLength = 1; req.OutputBuffer[0] = command; req.InputBufferLength = 2; rc = dr_u2c_transaction(hDevice, &req); switch (req.InputBuffer[0]) { case 0xC0: *pState = LS_RELEASED; break; case 0x00: *pState = LS_DROPPED_BY_I2C_BRIDGE; break; case 0x40: *pState = LS_DROPPED_BY_SLAVE; break; case 0x80: *pState = LS_RAISED_BY_I2C_BRIDGE; break; default: if (rc == U2C_SUCCESS) rc = U2C_UNKNOWN_ERROR; } return rc; } U2C_RESULT _stdcall U2C_ReadScl(HANDLE hDevice, U2C_LINE_STATE *pState) { return read_line_state(hDevice, pState, 0x09); } U2C_RESULT _stdcall U2C_ReadSda(HANDLE hDevice, U2C_LINE_STATE *pState) { return read_line_state(hDevice, pState, 0x08); } U2C_RESULT _stdcall U2C_ReleaseScl(HANDLE hDevice) { DEVICE_REQUEST req; req.OutputBufferLength = 1; req.OutputBuffer[0] = 0x05; req.InputBufferLength = 1; return dr_u2c_transaction(hDevice, &req); } U2C_RESULT _stdcall U2C_ReleaseSda(HANDLE hDevice) { DEVICE_REQUEST req; req.OutputBufferLength = 1; req.OutputBuffer[0] = 0x04; req.InputBufferLength = 1; return dr_u2c_transaction(hDevice, &req); } U2C_RESULT _stdcall U2C_DropScl(HANDLE hDevice) { DEVICE_REQUEST req; req.OutputBufferLength = 1; req.OutputBuffer[0] = 0x07; req.InputBufferLength = 1; return dr_u2c_transaction(hDevice, &req); } U2C_RESULT _stdcall U2C_DropSda(HANDLE hDevice) { DEVICE_REQUEST req; req.OutputBufferLength = 1; req.OutputBuffer[0] = 0x06; req.InputBufferLength = 1; return dr_u2c_transaction(hDevice, &req); } //----------------------------------------------------------------------------- // GPIO routines //----------------------------------------------------------------------------- U2C_RESULT _stdcall U2C_SetIoDirection(HANDLE hDevice, ULONG Value, ULONG Mask) { DEVICE_REQUEST req; Value = Value & Mask; Mask = ~Mask; req.OutputBufferLength = 7; req.OutputBuffer[0] = 0x17; req.OutputBuffer[1] = (BYTE)Mask; req.OutputBuffer[2] = (BYTE)Value; req.OutputBuffer[3] = (BYTE)(Mask >> 8); req.OutputBuffer[4] = (BYTE)(Value >> 8); req.OutputBuffer[5] = (BYTE)(Mask >> 16); req.OutputBuffer[6] = (BYTE)(Value >> 16); req.InputBufferLength = 1; return dr_u2c_transaction(hDevice, &req); } U2C_RESULT _stdcall U2C_GetIoDirection(HANDLE hDevice, ULONG *pValue) { U2C_RESULT rc; DEVICE_REQUEST req; req.OutputBufferLength = 1; req.OutputBuffer[0] = 0x18; req.InputBufferLength = 4; rc = dr_u2c_transaction(hDevice, &req); *pValue = req.InputBuffer[0]; (*pValue) |= (req.InputBuffer[1] << 8); (*pValue) |= (req.InputBuffer[2] << 16); return rc; } U2C_RESULT _stdcall U2C_IoWrite(HANDLE hDevice, ULONG Value, ULONG Mask) { DEVICE_REQUEST req; Value = Value & Mask; Mask = ~Mask; req.OutputBufferLength = 7; req.OutputBuffer[0] = 0x19; req.OutputBuffer[1] = (BYTE)Mask; req.OutputBuffer[2] = (BYTE)Value; req.OutputBuffer[3] = (BYTE)(Mask >> 8); req.OutputBuffer[4] = (BYTE)(Value >> 8); req.OutputBuffer[5] = (BYTE)(Mask >> 16); req.OutputBuffer[6] = (BYTE)(Value >> 16); req.InputBufferLength = 1; return dr_u2c_transaction(hDevice, &req); } U2C_RESULT _stdcall U2C_IoRead(HANDLE hDevice, ULONG *pValue) { U2C_RESULT rc; DEVICE_REQUEST req; req.OutputBufferLength = 1; req.OutputBuffer[0] = 0x1A; req.InputBufferLength = 4; rc = dr_u2c_transaction(hDevice, &req); *pValue = req.InputBuffer[0]; (*pValue) |= (req.InputBuffer[1] << 8); (*pValue) |= (req.InputBuffer[2] << 16); return rc; } U2C_RESULT _stdcall U2C_SetSingleIoDirection(HANDLE hDevice, ULONG IoNumber, BOOL bOutput) { ULONG Value = 0; ULONG Mask = 1; if (IoNumber >= 8*3) return U2C_BAD_PARAMETER; Mask <<= IoNumber; if (bOutput) Value = Mask; return U2C_SetIoDirection(hDevice, Value, Mask); } U2C_RESULT _stdcall U2C_GetSingleIoDirection(HANDLE hDevice, ULONG IoNumber, BOOL *pbOutput) { U2C_RESULT rc; ULONG Value; ULONG Mask = 1; if (IoNumber >= 8*3) return U2C_BAD_PARAMETER; rc = U2C_GetIoDirection(hDevice, &Value); Mask <<= IoNumber; if ((Value & Mask) == 0) *pbOutput = FALSE; else *pbOutput = TRUE; return rc; } U2C_RESULT _stdcall U2C_SingleIoWrite(HANDLE hDevice, ULONG IoNumber, BOOL Value) { ULONG val = 0; ULONG mask = 1; if (IoNumber >= 8*3) return U2C_BAD_PARAMETER; mask <<= IoNumber; if (Value) val = mask; return U2C_IoWrite(hDevice, val, mask); } U2C_RESULT _stdcall U2C_SingleIoRead(HANDLE hDevice, ULONG IoNumber, BOOL *pValue) { U2C_RESULT rc; ULONG val; ULONG mask = 1; if (IoNumber >= 8*3) return U2C_BAD_PARAMETER; rc = U2C_IoRead(hDevice, &val); mask <<= IoNumber; if ((val & mask) == 0) *pValue = FALSE; else *pValue = TRUE; return rc; } //----------------------------------------------------------------------------- // SPI configuration routines //----------------------------------------------------------------------------- U2C_RESULT _stdcall U2C_SpiSetConfigEx(HANDLE hDevice, DWORD Config) { DEVICE_REQUEST req; req.OutputBufferLength = 2; req.OutputBuffer[0] = 0x1D; req.OutputBuffer[1] = (UCHAR)Config; req.InputBufferLength = 1; return dr_u2c_transaction(hDevice, &req); } U2C_RESULT _stdcall U2C_SpiGetConfigEx(HANDLE hDevice, DWORD *pConfig) { DEVICE_REQUEST req; U2C_RESULT rc; req.OutputBufferLength = 1; req.OutputBuffer[0] = 0x1E; req.InputBufferLength = 2; rc = dr_u2c_transaction(hDevice, &req); *pConfig = req.InputBuffer[0]; return rc; } U2C_RESULT _stdcall U2C_SpiSetConfig(HANDLE hDevice, BYTE CPOL, BYTE CPHA) { DWORD config = 0x00; if (CPOL) config |= 0x1; if (CPHA) config |= 0x2; return U2C_SpiSetConfigEx(hDevice, config); } U2C_RESULT _stdcall U2C_SpiGetConfig(HANDLE hDevice, BYTE *pCPOL, BYTE *pCPHA) { DWORD config; U2C_RESULT rc = U2C_SpiGetConfigEx(hDevice, &config); if (config & 0x1) *pCPOL = 1; else *pCPOL = 0; if (config & 0x2) *pCPHA = 1; else *pCPHA = 0; return rc; } U2C_RESULT _stdcall U2C_SpiSetFreq(HANDLE hDevice, BYTE Frequency) { DEVICE_REQUEST req; req.OutputBufferLength = 2; req.OutputBuffer[0] = 0x1F; req.OutputBuffer[1] = Frequency; req.InputBufferLength = 1; return dr_u2c_transaction(hDevice, &req); } U2C_RESULT _stdcall U2C_SpiGetFreq(HANDLE hDevice, BYTE *pFrequency) { DEVICE_REQUEST req; U2C_RESULT rc; req.OutputBufferLength = 1; req.OutputBuffer[0] = 0x20; req.InputBufferLength = 2; rc = dr_u2c_transaction(hDevice, &req); *pFrequency = req.InputBuffer[0]; return rc; } //----------------------------------------------------------------------------- // SPI data transfer routines //----------------------------------------------------------------------------- U2C_RESULT _stdcall U2C_SpiReadWrite(HANDLE hDevice, BYTE *pOutBuffer, BYTE *pInBuffer, WORD Length) { DEVICE_REQUEST req; U2C_RESULT rc; if ((Length == 0) || (Length > 256)) return U2C_BAD_PARAMETER; req.OutputBufferLength = Length + 2; req.OutputBuffer[0] = 0x21; req.OutputBuffer[1] = (BYTE)Length; memcpy(req.OutputBuffer+2, pOutBuffer, Length); req.InputBufferLength = Length + 1; rc = dr_u2c_transaction(hDevice, &req); memcpy(pInBuffer, req.InputBuffer, Length); return rc; } U2C_RESULT _stdcall U2C_SpiWrite(HANDLE hDevice, BYTE *pOutBuffer, WORD Length) { DEVICE_REQUEST req; if ((Length == 0) || (Length > 256)) return U2C_BAD_PARAMETER; req.OutputBufferLength = Length + 2; req.OutputBuffer[0] = 0x23; req.OutputBuffer[1] = (BYTE)Length; memcpy(req.OutputBuffer+2, pOutBuffer, Length); req.InputBufferLength = 1; return dr_u2c_transaction(hDevice, &req); } U2C_RESULT _stdcall U2C_SpiRead(HANDLE hDevice, BYTE *pInBuffer, WORD Length) { DEVICE_REQUEST req; U2C_RESULT rc; if ((Length == 0) || (Length > 256)) return U2C_BAD_PARAMETER; req.OutputBufferLength = 2; req.OutputBuffer[0] = 0x22; req.OutputBuffer[1] = (BYTE)Length; req.InputBufferLength = Length + 1; rc = dr_u2c_transaction(hDevice, &req); memcpy(pInBuffer, req.InputBuffer, Length); return rc; } i2c_bridge-0.0.3/u2c/INSTALL0000755000175500010010000000113310333142063013452 0ustar USERNoneInstall Procedure ================= - Install libusb The official libusb web site: http://libusb.sourceforge.net/. Download latest libusb release libusb-x.x.x.tgz file Example: % tar -zxvf libusb-x.x.x.tar.gz % cd libusb-x.x.x % ./configure % make % make install By default libusb will be installed in /usr/local/lib /usr/local/include - Build i2cbrdg % tar -zxvf i2c_bridge.x.x.x.tgz % cd i2c_bridge.x.x.x/u2c % make % make install Makefile has LIBUSB_PREFIX variable by default preset as LIBUSB_PREFIX=/usr/local If you have installed libusb not in /usr/local/... , change this variable. i2c_bridge-0.0.3/u2c/Makefile0000755000175500010010000000170110333142665014072 0ustar USERNoneall: libi2cbrdg.a libi2cbrdg.so TESTS I2C # libusb ifndef LIBUSB_PREFIX LIBUSB_PREFIX := /usr/local endif INC_DIR += -I$(LIBUSB_PREFIX)/include LIB_DIR += -L$(LIBUSB_PREFIX)/lib LIB += -lusb CC = $(CROSS_COMPILE)gcc LD = $(CROSS_COMPILE)ld AR = $(CROSS_COMPILE)ar ### Regular builds CFLAGS += -MD -g -O2 -Wall -Werror -I. ${INC_DIR} LDFLAGS += ${LIB} ${LIB_DIR} %.o: %.c $(CC) $(CFLAGS) -c -o $@ $< lib%.a: $(AR) cr $@ $^ lib%.so: $(LD) $(LDFLAGS) -shared -o $@ $^ clean: rm -f *.o *.d *.a *.so make -C tests -f Makefile clean make -C i2c -f Makefile clean ### Target builds I2CBRDG_OBJ = i2cbridge.o dev_rout.o libi2cbrdg.a : $(I2CBRDG_OBJ) libi2cbrdg.so: $(I2CBRDG_OBJ) TESTS: make -C tests -f Makefile I2C: make -C i2c -f Makefile # Install install: install -c -m 644 ../common/i2cbridge.h $(LIBUSB_PREFIX)/include install -c -m 644 libi2cbrdg.so $(LIBUSB_PREFIX)/lib install -c -m 644 libi2cbrdg.a $(LIBUSB_PREFIX)/lib i2c_bridge-0.0.3/u2c/README0000755000175500010010000000007610333142063013306 0ustar USERNone0.0.3 ----- - New API functions 0.0.2 ----- - Updates, fixes i2c_bridge-0.0.3/u2c/tests/0000755000175500010010000000000010333143340013561 5ustar USERNonei2c_bridge-0.0.3/u2c/tests/func_test.c0000755000175500010010000001354510213346752015743 0ustar USERNone/* Copyright (C)2004 Dimax ( http://www.xdimax.com ) This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. */ /* *------------------------------------------------------------------- * Description: functional tester for i2cbrdg library *------------------------------------------------------------------- * Version: $Id: func_test.c,v 1.1 2005/03/08 16:08:10 dmitry_kulik Exp $ *------------------------------------------------------------------- */ #include #include //----------------------------------------------------------------------------- // Constants //----------------------------------------------------------------------------- #define I2C_PACK_COUNT 10 #define TEST_SA 0x51 //----------------------------------------------------------------------------- // Global Variables //----------------------------------------------------------------------------- //----------------------------------------------------------------------------- // Local Function Definition //----------------------------------------------------------------------------- //----------------------------------------------------------------------------- // MAIN //----------------------------------------------------------------------------- int main( int argc, char* argv[] ) { int rc=0; HANDLE hDevice; long sn; U2C_VERSION_INFO fwVersion; BYTE freq, prev_freq; U2C_SLAVE_ADDR_LIST slave_list; U2C_TRANSACTION trans; U2C_TRANSACTION_PACK trans_pack[I2C_PACK_COUNT]; int i,j; BYTE Data; // Enumerate rc = U2C_GetDeviceCount(); printf( "U2C_GetDeviceCount: found %d Dimax u2c-11 device(s)\n", rc ); if( rc == 0 ) return -1; // Open device '0' hDevice = U2C_OpenDevice( 0 ); if( hDevice == INVALID_HANDLE_VALUE ) return -1; printf( "U2C_OpenDevice(0): hDevice=%p\n", hDevice ); // Get Serial Number rc = U2C_GetSerialNum( hDevice, &sn ); if( rc ) return rc; printf( "U2C_GetSerialNum: %08lx\n", sn ); // Get FW Version rc = U2C_GetFirmwareVersion( hDevice, &fwVersion); if( rc ) return rc; printf( "U2C_GetFirmwareVersion: Major=%02hd Minor=%02hd\n", fwVersion.MajorVersion, fwVersion.MinorVersion ); // I2C slaves rc = U2C_ScanDevices(hDevice, &slave_list); if ( rc ) return rc; printf("Found %d I2C slave devices:\n ", slave_list.nDeviceNumber); for (i=0; i