1 |
39 |
julius |
/*++
|
2 |
|
|
|
3 |
|
|
FTC MPSSE Interface DLLs - Copyright © FTDI Ltd. 2009
|
4 |
|
|
|
5 |
|
|
|
6 |
|
|
The source code to the FTCI2C, FTCJTAG and FTCSPI DLLs is provided as-is and no warranty is made as to its function or reliability.
|
7 |
|
|
|
8 |
|
|
This source code may be freely modified and redistributed, provided that the FTDI Ltd. copyright notice remains intact.
|
9 |
|
|
|
10 |
|
|
Copyright (c) 2005 Future Technology Devices International Ltd.
|
11 |
|
|
|
12 |
|
|
Module Name:
|
13 |
|
|
|
14 |
|
|
ft2232cmpssejtag.h
|
15 |
|
|
|
16 |
|
|
Abstract:
|
17 |
|
|
|
18 |
|
|
FT2232C Dual Device Device Class Declaration/Definition.
|
19 |
|
|
|
20 |
|
|
Environment:
|
21 |
|
|
|
22 |
|
|
kernel & user mode
|
23 |
|
|
|
24 |
|
|
Revision History:
|
25 |
|
|
|
26 |
|
|
07/02/05 kra Created.
|
27 |
|
|
24/08/05 kra Added new function JTAG_GenerateClockPulses and new error code FTC_INVALID_NUMBER_CLOCK_PULSES
|
28 |
|
|
16/09/05 kra Version 1.50 - Added break statements after DLL_THREAD_ATTACH and DLL_THREAD_DETACH for multiple threaded applications
|
29 |
|
|
08/03/06 ana Version 1.08 - fix byte boundry mising bit.
|
30 |
|
|
19/11/08 Rene Baumann Port FTCJTAG to Linux.
|
31 |
|
|
|
32 |
|
|
--*/
|
33 |
|
|
|
34 |
|
|
#ifndef FT2232cMpsseJtag_H
|
35 |
|
|
#define FT2232cMpsseJtag_H
|
36 |
|
|
|
37 |
|
|
//#include <windows.h>
|
38 |
|
|
|
39 |
|
|
#include "FT2232c.h"
|
40 |
|
|
//#include "FTCJTAG.h" -- All required bits now included in this file. WinAPI things in there not needed here
|
41 |
|
|
|
42 |
|
|
|
43 |
|
|
// Defines from FTCJTAG.h
|
44 |
|
|
|
45 |
|
|
typedef DWORD FTC_HANDLE;
|
46 |
|
|
typedef ULONG FTC_STATUS;
|
47 |
|
|
|
48 |
|
|
#define TEST_LOGIC_STATE 1
|
49 |
|
|
#define RUN_TEST_IDLE_STATE 2
|
50 |
|
|
#define PAUSE_TEST_DATA_REGISTER_STATE 3
|
51 |
|
|
#define PAUSE_INSTRUCTION_REGISTER_STATE 4
|
52 |
|
|
#define SHIFT_TEST_DATA_REGISTER_STATE 5
|
53 |
|
|
#define SHIFT_INSTRUCTION_REGISTER_STATE 6
|
54 |
|
|
|
55 |
|
|
#define FTC_SUCCESS 0 // FTC_OK
|
56 |
|
|
#define FTC_INVALID_HANDLE 1 // FTC_INVALID_HANDLE
|
57 |
|
|
#define FTC_DEVICE_NOT_FOUND 2 //FTC_DEVICE_NOT_FOUND
|
58 |
|
|
#define FTC_DEVICE_NOT_OPENED 3 //FTC_DEVICE_NOT_OPENED
|
59 |
|
|
#define FTC_IO_ERROR 4 //FTC_IO_ERROR
|
60 |
|
|
#define FTC_INSUFFICIENT_RESOURCES 5 // FTC_INSUFFICIENT_RESOURCES
|
61 |
|
|
|
62 |
|
|
#define FTC_FAILED_TO_COMPLETE_COMMAND 20 // cannot change, error code mapped from FT2232c classes
|
63 |
|
|
#define FTC_FAILED_TO_SYNCHRONIZE_DEVICE_MPSSE 21 // cannot change, error code mapped from FT2232c classes
|
64 |
|
|
#define FTC_INVALID_DEVICE_NAME_INDEX 22 // cannot change, error code mapped from FT2232c classes
|
65 |
|
|
#define FTC_NULL_DEVICE_NAME_BUFFER_POINTER 23 // cannot change, error code mapped from FT2232c classes
|
66 |
|
|
#define FTC_DEVICE_NAME_BUFFER_TOO_SMALL 24 // cannot change, error code mapped from FT2232c classes
|
67 |
|
|
#define FTC_INVALID_DEVICE_NAME 25 // cannot change, error code mapped from FT2232c classes
|
68 |
|
|
#define FTC_INVALID_LOCATION_ID 26 // cannot change, error code mapped from FT2232c classes
|
69 |
|
|
#define FTC_DEVICE_IN_USE 27 // cannot change, error code mapped from FT2232c classes
|
70 |
|
|
#define FTC_TOO_MANY_DEVICES 28 // cannot change, error code mapped from FT2232c classes
|
71 |
|
|
#define FTC_INVALID_CLOCK_DIVISOR 29
|
72 |
|
|
#define FTC_NULL_INPUT_OUTPUT_BUFFER_POINTER 30
|
73 |
|
|
#define FTC_INVALID_NUMBER_BITS 31
|
74 |
|
|
#define FTC_NULL_WRITE_DATA_BUFFER_POINTER 32
|
75 |
|
|
#define FTC_INVALID_NUMBER_BYTES 33
|
76 |
|
|
#define FTC_NUMBER_BYTES_TOO_SMALL 34
|
77 |
|
|
#define FTC_INVALID_TAP_CONTROLLER_STATE 35
|
78 |
|
|
#define FTC_NULL_READ_DATA_BUFFER_POINTER 36
|
79 |
|
|
#define FTC_COMMAND_SEQUENCE_BUFFER_FULL 37
|
80 |
|
|
#define FTC_NULL_READ_CMDS_DATA_BUFFER_POINTER 38
|
81 |
|
|
#define FTC_NO_COMMAND_SEQUENCE 39
|
82 |
|
|
#define FTC_INVALID_NUMBER_CLOCK_PULSES 40
|
83 |
|
|
#define FTC_NULL_DLL_VERSION_BUFFER_POINTER 41
|
84 |
|
|
#define FTC_DLL_VERSION_BUFFER_TOO_SMALL 42
|
85 |
|
|
#define FTC_NULL_LANGUAGE_CODE_BUFFER_POINTER 43
|
86 |
|
|
#define FTC_NULL_ERROR_MESSAGE_BUFFER_POINTER 44
|
87 |
|
|
#define FTC_ERROR_MESSAGE_BUFFER_TOO_SMALL 45
|
88 |
|
|
#define FTC_INVALID_LANGUAGE_CODE 46
|
89 |
|
|
#define FTC_INVALID_STATUS_CODE 47
|
90 |
|
|
|
91 |
|
|
|
92 |
|
|
typedef struct Ft_Input_Output_Pins{
|
93 |
|
|
BOOL bPin1InputOutputState;
|
94 |
|
|
BOOL bPin1LowHighState;
|
95 |
|
|
BOOL bPin2InputOutputState;
|
96 |
|
|
BOOL bPin2LowHighState;
|
97 |
|
|
BOOL bPin3InputOutputState;
|
98 |
|
|
BOOL bPin3LowHighState;
|
99 |
|
|
BOOL bPin4InputOutputState;
|
100 |
|
|
BOOL bPin4LowHighState;
|
101 |
|
|
}FTC_INPUT_OUTPUT_PINS, *PFTC_INPUT_OUTPUT_PINS;
|
102 |
|
|
typedef struct Ft_Low_High_Pins{
|
103 |
|
|
BOOL bPin1LowHighState;
|
104 |
|
|
BOOL bPin2LowHighState;
|
105 |
|
|
BOOL bPin3LowHighState;
|
106 |
|
|
BOOL bPin4LowHighState;
|
107 |
|
|
}FTC_LOW_HIGH_PINS, *PFTC_LOW_HIGH_PINS;
|
108 |
|
|
#define MAX_WRITE_DATA_BYTES_BUFFER_SIZE 65536 // 64k bytes
|
109 |
|
|
|
110 |
|
|
typedef BYTE WriteDataByteBuffer[MAX_WRITE_DATA_BYTES_BUFFER_SIZE];
|
111 |
|
|
typedef WriteDataByteBuffer *PWriteDataByteBuffer;
|
112 |
|
|
|
113 |
|
|
|
114 |
|
|
#define MAX_READ_DATA_BYTES_BUFFER_SIZE 65536 // 64k bytes
|
115 |
|
|
|
116 |
|
|
typedef BYTE ReadDataByteBuffer[MAX_READ_DATA_BYTES_BUFFER_SIZE];
|
117 |
|
|
typedef ReadDataByteBuffer *PReadDataByteBuffer;
|
118 |
|
|
|
119 |
|
|
#define MAX_READ_CMDS_DATA_BYTES_BUFFER_SIZE 131071 // 128K bytes
|
120 |
|
|
|
121 |
|
|
typedef BYTE ReadCmdSequenceDataByteBuffer[MAX_READ_CMDS_DATA_BYTES_BUFFER_SIZE];
|
122 |
|
|
typedef ReadCmdSequenceDataByteBuffer *PReadCmdSequenceDataByteBuffer;
|
123 |
|
|
|
124 |
|
|
|
125 |
|
|
// end defines from FTCJTAG.h
|
126 |
|
|
|
127 |
|
|
|
128 |
|
|
#define DEVICE_CHANNEL_A " A"
|
129 |
|
|
#define DEVICE_CHANNEL_B " B"
|
130 |
|
|
|
131 |
|
|
#define DLL_VERSION_NUM "1.8"
|
132 |
|
|
|
133 |
|
|
#define USB_INPUT_BUFFER_SIZE 65536 // 64K
|
134 |
|
|
#define USB_OUTPUT_BUFFER_SIZE 65536 // 64K
|
135 |
|
|
|
136 |
|
|
const BYTE FT_EVENT_VALUE = 0;
|
137 |
|
|
const BYTE FT_ERROR_VALUE = 0;
|
138 |
|
|
|
139 |
|
|
#define DEVICE_READ_TIMEOUT_INFINITE 0
|
140 |
|
|
#define DEVICE_WRITE_TIMEOUT 5000 // 5 seconds
|
141 |
|
|
|
142 |
|
|
#define MIN_CLOCK_DIVISOR 0 // equivalent to 6MHz
|
143 |
|
|
#define MAX_CLOCK_DIVISOR 65535 // equivalent to 91Hz
|
144 |
|
|
|
145 |
|
|
#define MIN_NUM_BITS 2 // specifies the minimum number of bits that can be written or read to/from an external device
|
146 |
|
|
#define MAX_NUM_BITS 524280 // specifies the maximum number of bits that can be written or read to/from an external device
|
147 |
|
|
#define MIN_NUM_BYTES 1 // specifies the minimum number of bytes that can be written to an external device
|
148 |
|
|
#define MAX_NUM_BYTES 65535 // specifies the maximum number of bytes that can be written to an external device
|
149 |
|
|
|
150 |
|
|
#define NUMBITSINBYTE 8
|
151 |
|
|
|
152 |
|
|
#define MIN_NUM_CLOCK_PULSES 1 // specifies the minimum number of clock pulses that a FT2232C dual device can generate
|
153 |
|
|
#define MAX_NUM_CLOCK_PULSES 2000000000 // specifies the maximum number of clock pulses that a FT2232C dual device can generate
|
154 |
|
|
|
155 |
|
|
#define NUM_BYTE_CLOCK_PULSES_BLOCK_SIZE 32000 //4000
|
156 |
|
|
|
157 |
|
|
#define PIN1_HIGH_VALUE 1
|
158 |
|
|
#define PIN2_HIGH_VALUE 2
|
159 |
|
|
#define PIN3_HIGH_VALUE 4
|
160 |
|
|
#define PIN4_HIGH_VALUE 8
|
161 |
|
|
|
162 |
|
|
#define NUM_WRITE_COMMAND_BYTES 18
|
163 |
|
|
#define NUM_READ_COMMAND_BYTES 18
|
164 |
|
|
#define NUM_WRITE_READ_COMMAND_BYTES 19
|
165 |
|
|
|
166 |
|
|
#define MAX_ERROR_MSG_SIZE 250
|
167 |
|
|
|
168 |
|
|
const CHAR ENGLISH[3] = "EN";
|
169 |
|
|
|
170 |
|
|
const CHAR EN_Common_Errors[FTC_INSUFFICIENT_RESOURCES + 1][MAX_ERROR_MSG_SIZE] = {
|
171 |
|
|
"",
|
172 |
|
|
"Invalid device handle.",
|
173 |
|
|
"Device not found.",
|
174 |
|
|
"Device not opened.",
|
175 |
|
|
"General device IO error.",
|
176 |
|
|
"Insufficient resources available to execute function."};
|
177 |
|
|
|
178 |
|
|
const CHAR EN_New_Errors[(FTC_INVALID_STATUS_CODE - FTC_FAILED_TO_COMPLETE_COMMAND) + 1][MAX_ERROR_MSG_SIZE] = {
|
179 |
|
|
"Failed to complete command.",
|
180 |
|
|
"Failed to synchronize the device MPSSE interface.",
|
181 |
|
|
"Invalid device name index.",
|
182 |
|
|
"Pointer to device name buffer is null.",
|
183 |
|
|
"Buffer to contain device name is too small.",
|
184 |
|
|
"Invalid device name.",
|
185 |
|
|
"Invalid device location identifier.",
|
186 |
|
|
"Device already in use by another application.",
|
187 |
|
|
"More than one device detected.",
|
188 |
|
|
"Invalid clock divisor. Valid range is 0 - 65535.",
|
189 |
|
|
"Pointer to input output buffer is null.",
|
190 |
|
|
"Invalid number of bits. Valid range 2 to 524280. 524280 bits is equivalent to 64K bytes",
|
191 |
|
|
"Pointer to write data buffer is null.",
|
192 |
|
|
"Invalid size of write data buffer. Valid range is 1 - 65535",
|
193 |
|
|
"Buffer to contain number of bits is too small.",
|
194 |
|
|
"Invalid Test Access Port(TAP) controller state.",
|
195 |
|
|
"Pointer to read data buffer is null.",
|
196 |
|
|
"Command sequence buffer is full. Valid range is 1 - 131070 ie 128K bytes.",
|
197 |
|
|
"Pointer to read command sequence data buffer is null.",
|
198 |
|
|
"No command sequence found.",
|
199 |
|
|
"Invalid number of clock pulses. Valid range is 1 - 2000,000,000.",
|
200 |
|
|
"Pointer to dll version number buffer is null.",
|
201 |
|
|
"Buffer to contain dll version number is too small.",
|
202 |
|
|
"Pointer to language code buffer is null.",
|
203 |
|
|
"Pointer to error message buffer is null.",
|
204 |
|
|
"Buffer to contain error message is too small.",
|
205 |
|
|
"Unsupported language code.",
|
206 |
|
|
"Unknown status code = "};
|
207 |
|
|
|
208 |
|
|
const BYTE CLK_DATA_BYTES_OUT_ON_NEG_CLK_LSB_FIRST_CMD = '\x19';
|
209 |
|
|
const BYTE CLK_DATA_BITS_OUT_ON_NEG_CLK_LSB_FIRST_CMD = '\x1B';
|
210 |
|
|
const BYTE CLK_DATA_BYTES_IN_ON_POS_CLK_LSB_FIRST_CMD = '\x28';
|
211 |
|
|
const BYTE CLK_DATA_BITS_IN_ON_POS_CLK_LSB_FIRST_CMD = '\x2A';
|
212 |
|
|
const BYTE CLK_DATA_BYTES_OUT_ON_NEG_CLK_IN_ON_POS_CLK_LSB_FIRST_CMD = '\x39';
|
213 |
|
|
const BYTE CLK_DATA_BITS_OUT_ON_NEG_CLK_IN_ON_POS_CLK_LSB_FIRST_CMD = '\x3B';
|
214 |
|
|
|
215 |
|
|
const BYTE CLK_DATA_TMS_NO_READ_CMD = '\x4B';
|
216 |
|
|
const BYTE CLK_DATA_TMS_READ_CMD = '\x6B';
|
217 |
|
|
|
218 |
|
|
const BYTE SET_LOW_BYTE_DATA_BITS_CMD = '\x80';
|
219 |
|
|
const BYTE GET_LOW_BYTE_DATA_BITS_CMD = '\x81';
|
220 |
|
|
const BYTE SET_HIGH_BYTE_DATA_BITS_CMD = '\x82';
|
221 |
|
|
const BYTE GET_HIGH_BYTE_DATA_BITS_CMD = '\x83';
|
222 |
|
|
const BYTE SET_CLOCK_FREQUENCY_CMD = '\x86';
|
223 |
|
|
const BYTE SEND_ANSWER_BACK_IMMEDIATELY_CMD = '\x87';
|
224 |
|
|
|
225 |
|
|
enum JtagStates {TestLogicReset, RunTestIdle, PauseDataRegister, PauseInstructionRegister, ShiftDataRegister, ShiftInstructionRegister, Undefined};
|
226 |
|
|
|
227 |
|
|
#define NUM_JTAG_TMS_STATES 6
|
228 |
|
|
|
229 |
|
|
// go from current JTAG state to new JTAG state -> tlr rti pdr pir sdr sir
|
230 |
|
|
const BYTE TestLogicResetToNewJTAGState[NUM_JTAG_TMS_STATES] = {'\x01', '\x00', '\x0A', '\x16', '\x02', '\x06'};
|
231 |
|
|
const BYTE RunTestIdleToNewJTAGState[NUM_JTAG_TMS_STATES] = {'\x07', '\x00', '\x05', '\x0B', '\x01', '\x03'};
|
232 |
|
|
const BYTE PauseDataRegToNewJTAGState[NUM_JTAG_TMS_STATES] = {'\x1F', '\x03', '\x17', '\x2F', '\x01', '\x0F'};
|
233 |
|
|
const BYTE PauseInstructionRegToNewJTAGState[NUM_JTAG_TMS_STATES] = {'\x1F', '\x03', '\x17', '\x2F', '\x07', '\x01'};
|
234 |
|
|
const BYTE ShiftDataRegToNewJTAGState[NUM_JTAG_TMS_STATES] = {'\x1F', '\x03', '\x01', '\x2F', '\x00', '\x00'};
|
235 |
|
|
const BYTE ShiftInstructionRegToNewJTAGState[NUM_JTAG_TMS_STATES] = {'\x1F', '\x03', '\x17', '\x01', '\x00', '\x00'};
|
236 |
|
|
|
237 |
|
|
// number of TMS clocks to go from current JTAG state to new JTAG state -> tlr rti pdr pir sdr sir
|
238 |
|
|
const BYTE TestLogicResetToNewJTAGStateNumTMSClocks[NUM_JTAG_TMS_STATES] = {1, 1, 5, 6, 4, 5};
|
239 |
|
|
const BYTE RunTestIdleToNewJTAGStateNumTMSClocks[NUM_JTAG_TMS_STATES] = {3, 5, 4, 5, 3, 4};
|
240 |
|
|
const BYTE PauseDataRegToNewJTAGStateNumTMSClocks[NUM_JTAG_TMS_STATES] = {5, 3, 6, 7, 2, 6};
|
241 |
|
|
const BYTE PauseInstructionRegToNewJTAGStateNumTMSClocks[NUM_JTAG_TMS_STATES] = {5, 3, 6, 7, 5, 2};
|
242 |
|
|
const BYTE ShiftDataRegToNewJTAGStateNumTMSClocks[NUM_JTAG_TMS_STATES] = {5, 3, 2, 7, 0, 0};
|
243 |
|
|
const BYTE ShiftInstructionRegToNewJTAGStateNumTMSClocks[NUM_JTAG_TMS_STATES] = {5, 4, 6, 2, 0, 0};
|
244 |
|
|
|
245 |
|
|
#define NO_LAST_DATA_BIT 0
|
246 |
|
|
|
247 |
|
|
#define NUM_COMMAND_SEQUENCE_READ_DATA_BYTES 2
|
248 |
|
|
#define INIT_COMMAND_SEQUENCE_READ_DATA_BUFFER_SIZE 100
|
249 |
|
|
#define COMMAND_SEQUENCE_READ_DATA_BUFFER_SIZE_INCREMENT 10
|
250 |
|
|
|
251 |
|
|
typedef DWORD ReadCommandSequenceData[NUM_COMMAND_SEQUENCE_READ_DATA_BYTES];
|
252 |
|
|
typedef ReadCommandSequenceData *PReadCommandSequenceData;
|
253 |
|
|
|
254 |
|
|
typedef PReadCommandSequenceData ReadCommandsSequenceData[1];
|
255 |
|
|
typedef ReadCommandsSequenceData *PReadCommandsSequenceData;
|
256 |
|
|
|
257 |
|
|
typedef struct Ft_Device_Cmd_Sequence_Data{
|
258 |
|
|
DWORD hDevice; // handle to the opened and initialized FT2232C dual type device
|
259 |
|
|
DWORD dwNumBytesToSend;
|
260 |
|
|
POutputByteBuffer pCommandsSequenceDataOutPutBuffer;
|
261 |
|
|
DWORD dwSizeReadCommandsSequenceDataBuffer;
|
262 |
|
|
PReadCommandsSequenceData pReadCommandsSequenceDataBuffer;
|
263 |
|
|
DWORD dwNumReadCommandSequences;
|
264 |
|
|
}FTC_DEVICE_CMD_SEQUENCE_DATA, *PFTC_DEVICE_CMD_SEQUENCE_DATA;
|
265 |
|
|
|
266 |
|
|
|
267 |
|
|
static DWORD dwSavedLowPinsDirection = 0; // Removed from FT2232cMpsseJtag class to avoid segmentation fault. Rene
|
268 |
|
|
static DWORD dwSavedLowPinsValue = 0; // Removed from FT2232cMpsseJtag class to avoid segmentation fault. Rene
|
269 |
|
|
static JtagStates CurrentJtagState = Undefined; // Removed from FT2232cMpsseJtag class to avoid segmentation fault. Rene
|
270 |
|
|
static DWORD dwNumOpenedDevices = 0; // Removed from FT2232cMpsseJtag class to avoid segmentation fault. Rene
|
271 |
|
|
static FTC_DEVICE_CMD_SEQUENCE_DATA OpenedDevicesCommandsSequenceData[MAX_NUM_DEVICES]; // Removed from FT2232cMpsseJtag class to avoid segmentation fault. Rene
|
272 |
|
|
static INT iCommandsSequenceDataDeviceIndex = -1; // Removed from FT2232cMpsseJtag class to avoid segmentation fault. Rene
|
273 |
|
|
|
274 |
|
|
|
275 |
|
|
//----------------------------------------------------------------------------
|
276 |
|
|
class FT2232cMpsseJtag : private FT2232c
|
277 |
|
|
{
|
278 |
|
|
private:
|
279 |
|
|
// Moved out from this class to avoid segmentation fault. --> DWORD dwSavedLowPinsDirection; // Rene
|
280 |
|
|
// Moved out from this class to avoid segmentation fault. --> DWORD dwSavedLowPinsValue; // Rene
|
281 |
|
|
// Moved out from this class to avoid segmentation fault. --> JtagStates CurrentJtagState; // Rene
|
282 |
|
|
// Moved out from this class to avoid segmentation fault. --> DWORD dwNumOpenedDevices; // Rene
|
283 |
|
|
// Moved out from this class to avoid segmentation fault. --> FTC_DEVICE_CMD_SEQUENCE_DATA OpenedDevicesCommandsSequenceData[MAX_NUM_DEVICES]; // Rene
|
284 |
|
|
// Moved out from this class to avoid segmentation fault. --> INT iCommandsSequenceDataDeviceIndex; // Rene
|
285 |
|
|
|
286 |
|
|
FTC_STATUS CheckWriteDataToExternalDeviceBitsBytesParameters(DWORD dwNumBitsToWrite, DWORD dwNumBytesToWrite);
|
287 |
|
|
|
288 |
|
|
void AddByteToOutputBuffer(DWORD dwOutputByte, BOOL bClearOutputBuffer);
|
289 |
|
|
FTC_STATUS SetDataInOutClockFrequency(FTC_HANDLE ftHandle, DWORD dwClockDivisor);
|
290 |
|
|
FTC_STATUS InitDataInOutClockFrequency(FTC_HANDLE ftHandle, DWORD dwClockDivisor);
|
291 |
|
|
void SetJTAGToNewState(DWORD dwNewJtagState, DWORD dwNumTmsClocks, BOOL bDoReadOperation);
|
292 |
|
|
DWORD MoveJTAGFromOneStateToAnother(JtagStates NewJtagState, DWORD dwLastDataBit, BOOL bDoReadOperation);
|
293 |
|
|
FTC_STATUS ResetTAPContollerExternalDeviceSetToTestIdleMode(FTC_HANDLE ftHandle);
|
294 |
|
|
FTC_STATUS SetGeneralPurposeInputOutputPins(FTC_HANDLE ftHandle, BOOL bControlLowInputOutputPins,
|
295 |
|
|
DWORD dwLowPinsDirection, DWORD dwLowPinsValue,
|
296 |
|
|
BOOL bControlHighInputOutputPins,
|
297 |
|
|
DWORD dwHighPinsDirection, DWORD dwHighPinsValue);
|
298 |
|
|
void GetGeneralPurposeInputOutputPinsInputStates(DWORD dwInputStatesReturnedValue, PFTC_LOW_HIGH_PINS pPinsInputData);
|
299 |
|
|
FTC_STATUS GetGeneralPurposeInputOutputPins(FTC_HANDLE ftHandle, BOOL bControlLowInputOutputPins,
|
300 |
|
|
PFTC_LOW_HIGH_PINS pLowPinsInputData,
|
301 |
|
|
BOOL bControlHighInputOutputPins,
|
302 |
|
|
PFTC_LOW_HIGH_PINS pHighPinsInputData);
|
303 |
|
|
void AddWriteCommandDataToOutPutBuffer(BOOL bInstructionTestData, DWORD dwNumBitsToWrite,
|
304 |
|
|
PWriteDataByteBuffer pWriteDataBuffer, DWORD dwNumBytesToWrite,
|
305 |
|
|
DWORD dwTapControllerState);
|
306 |
|
|
FTC_STATUS WriteDataToExternalDevice(FTC_HANDLE ftHandle, BOOL bInstructionData, DWORD dwNumBitsToWrite,
|
307 |
|
|
PWriteDataByteBuffer pWriteDataBuffer, DWORD dwNumBytesToWrite,
|
308 |
|
|
DWORD dwTapControllerState);
|
309 |
|
|
void GetNumDataBytesToRead(DWORD dwNumBitsToRead, LPDWORD lpdwNumDataBytesToRead, LPDWORD lpdwNumRemainingDataBits);
|
310 |
|
|
FTC_STATUS GetDataFromExternalDevice(FTC_HANDLE ftHandle, DWORD dwNumBitsToRead, DWORD dwNumTmsClocks,
|
311 |
|
|
PReadDataByteBuffer pReadDataBuffer, LPDWORD lpdwNumBytesReturned);
|
312 |
|
|
DWORD AddReadCommandToOutputBuffer(BOOL bInstructionTestData, DWORD dwNumBitsToRead, DWORD dwTapControllerState);
|
313 |
|
|
FTC_STATUS ReadDataFromExternalDevice(FTC_HANDLE ftHandle, BOOL bInstructionTestData, DWORD dwNumBitsToRead,
|
314 |
|
|
PReadDataByteBuffer pReadDataBuffer, LPDWORD lpdwNumBytesReturned,
|
315 |
|
|
DWORD dwTapControllerState);
|
316 |
|
|
DWORD AddWriteReadCommandDataToOutPutBuffer(BOOL bInstructionTestData, DWORD dwNumBitsToWriteRead,
|
317 |
|
|
PWriteDataByteBuffer pWriteDataBuffer,
|
318 |
|
|
DWORD dwNumBytesToWrite, DWORD dwTapControllerState);
|
319 |
|
|
FTC_STATUS WriteReadDataToFromExternalDevice(FTC_HANDLE ftHandle, BOOL bInstructionTestData, DWORD dwNumBitsToWriteRead,
|
320 |
|
|
PWriteDataByteBuffer pWriteDataBuffer, DWORD dwNumBytesToWrite,
|
321 |
|
|
PReadDataByteBuffer pReadDataBuffer, LPDWORD lpdwNumBytesReturned,
|
322 |
|
|
DWORD dwTapControllerState);
|
323 |
|
|
FTC_STATUS GenerateTCKClockPulses(FTC_HANDLE ftHandle, DWORD dwNumClockPulses);
|
324 |
|
|
|
325 |
|
|
void ProcessReadCommandsSequenceBytes(PInputByteBuffer pInputBuffer, DWORD dwNumBytesRead, PReadCmdSequenceDataByteBuffer pReadCmdSequenceDataBuffer,
|
326 |
|
|
LPDWORD lpdwNumBytesReturned);
|
327 |
|
|
DWORD GetTotalNumCommandsSequenceDataBytesToRead (void);
|
328 |
|
|
void CopyReadCommandsSequenceDataBuffer(PReadCommandsSequenceData pDestinationBuffer, PReadCommandsSequenceData pSourceBuffer, DWORD dwSizeReadCommandsSequenceDataBuffer);
|
329 |
|
|
FTC_STATUS AddReadCommandSequenceData(DWORD dwNumBitsToRead, DWORD dwNumTmsClocks);
|
330 |
|
|
void CreateReadCommandsSequenceDataBuffer(void);
|
331 |
|
|
PReadCommandsSequenceData CreateReadCommandsSequenceDataBuffer(DWORD dwSizeReadCmdsSequenceDataBuffer);
|
332 |
|
|
void DeleteReadCommandsSequenceDataBuffer(PReadCommandsSequenceData pReadCmdsSequenceDataBuffer, DWORD dwSizeReadCommandsSequenceDataBuffer);
|
333 |
|
|
|
334 |
|
|
FTC_STATUS CreateDeviceCommandsSequenceDataBuffers(FTC_HANDLE ftHandle);
|
335 |
|
|
void ClearDeviceCommandSequenceData(FTC_HANDLE ftHandle);
|
336 |
|
|
DWORD GetNumBytesInCommandsSequenceDataBuffer(void);
|
337 |
|
|
DWORD GetCommandsSequenceDataDeviceIndex(FTC_HANDLE ftHandle);
|
338 |
|
|
void DeleteDeviceCommandsSequenceDataBuffers(FTC_HANDLE ftHandle);
|
339 |
|
|
|
340 |
|
|
FTC_STATUS AddDeviceWriteCommand(FTC_HANDLE ftHandle, BOOL bInstructionTestData, DWORD dwNumBitsToWrite,
|
341 |
|
|
PWriteDataByteBuffer pWriteDataBuffer, DWORD dwNumBytesToWrite,
|
342 |
|
|
DWORD dwTapControllerState);
|
343 |
|
|
FTC_STATUS AddDeviceReadCommand(FTC_HANDLE ftHandle, BOOL bInstructionTestData, DWORD dwNumBitsToRead, DWORD dwTapControllerState);
|
344 |
|
|
FTC_STATUS AddDeviceWriteReadCommand(FTC_HANDLE ftHandle, BOOL bInstructionTestData, DWORD dwNumBitsToWriteRead,
|
345 |
|
|
PWriteDataByteBuffer pWriteDataBuffer, DWORD dwNumBytesToWrite,
|
346 |
|
|
DWORD dwTapControllerState);
|
347 |
|
|
|
348 |
|
|
public:
|
349 |
|
|
FT2232cMpsseJtag(void);
|
350 |
|
|
~FT2232cMpsseJtag(void);
|
351 |
|
|
|
352 |
|
|
|
353 |
|
|
FTC_STATUS JTAG_GetNumDevices(LPDWORD lpdwNumDevices);
|
354 |
|
|
FTC_STATUS JTAG_GetDeviceNameLocationID(DWORD dwDeviceNameIndex, LPSTR lpDeviceNameBuffer, DWORD dwBufferSize, LPDWORD lpdwLocationID);
|
355 |
|
|
//FTC_STATUS JTAG_GetDeviceNameLocID(DWORD dwDeviceNameIndex, LPSTR lpDeviceNameBuffer, DWORD dwBufferSize, LPDWORD lpdwLocationID);
|
356 |
|
|
FTC_STATUS JTAG_OpenSpecifiedDevice(LPSTR lpDeviceName, DWORD dwLocationID, FTC_HANDLE *pftHandle);
|
357 |
|
|
//FTC_STATUS JTAG_OpenEx(LPSTR lpDeviceName, DWORD dwLocationID, FTC_HANDLE *pftHandle);
|
358 |
|
|
FTC_STATUS JTAG_OpenDevice(FTC_HANDLE *pftHandle);
|
359 |
|
|
//FTC_STATUS JTAG_Open(FTC_HANDLE *pftHandle);
|
360 |
|
|
FTC_STATUS JTAG_CloseDevice(FTC_HANDLE ftHandle);
|
361 |
|
|
//FTC_STATUS JTAG_Close(FTC_HANDLE ftHandle);
|
362 |
|
|
FTC_STATUS JTAG_InitDevice(FTC_HANDLE ftHandle, DWORD dwClockFrequencyValue);
|
363 |
|
|
FTC_STATUS JTAG_GetClock(DWORD dwClockDivisor, LPDWORD lpdwClockFrequencyHz);
|
364 |
|
|
FTC_STATUS JTAG_SetClock(FTC_HANDLE ftHandle, DWORD dwClockDivisor, LPDWORD lpdwClockFrequencyHz);
|
365 |
|
|
FTC_STATUS JTAG_SetDeviceLoopbackState(FTC_HANDLE ftHandle, BOOL bLoopbackState);
|
366 |
|
|
//FTC_STATUS JTAG_SetLoopback(FTC_HANDLE ftHandle, BOOL bLoopbackState);
|
367 |
|
|
FTC_STATUS JTAG_SetGeneralPurposeInputOutputPins(FTC_HANDLE ftHandle, BOOL bControlLowInputOutputPins,
|
368 |
|
|
//FTC_STATUS JTAG_SetGPIOs(FTC_HANDLE ftHandle, BOOL bControlLowInputOutputPins,
|
369 |
|
|
PFTC_INPUT_OUTPUT_PINS pLowInputOutputPinsData,
|
370 |
|
|
BOOL bControlHighInputOutputPins,
|
371 |
|
|
PFTC_INPUT_OUTPUT_PINS pHighInputOutputPinsData);
|
372 |
|
|
FTC_STATUS JTAG_GetGeneralPurposeInputOutputPins(FTC_HANDLE ftHandle, BOOL bControlLowInputOutputPins,
|
373 |
|
|
//FTC_STATUS JTAG_GetGPIOs(FTC_HANDLE ftHandle, BOOL bControlLowInputOutputPins,
|
374 |
|
|
PFTC_LOW_HIGH_PINS pLowPinsInputData,
|
375 |
|
|
BOOL bControlHighInputOutputPins,
|
376 |
|
|
PFTC_LOW_HIGH_PINS pHighPinsInputData);
|
377 |
|
|
FTC_STATUS JTAG_WriteDataToExternalDevice(FTC_HANDLE ftHandle, BOOL bInstructionTestData, DWORD dwNumBitsToWrite,
|
378 |
|
|
//FTC_STATUS JTAG_Write(FTC_HANDLE ftHandle, BOOL bInstructionTestData, DWORD dwNumBitsToWrite,
|
379 |
|
|
PWriteDataByteBuffer pWriteDataBuffer, DWORD dwNumBytesToWrite,
|
380 |
|
|
DWORD dwTapControllerState);
|
381 |
|
|
FTC_STATUS JTAG_ReadDataFromExternalDevice(FTC_HANDLE ftHandle, BOOL bInstructionTestData, DWORD dwNumBitsToRead,
|
382 |
|
|
//FTC_STATUS JTAG_Read(FTC_HANDLE ftHandle, BOOL bInstructionTestData, DWORD dwNumBitsToRead,
|
383 |
|
|
PReadDataByteBuffer pReadDataBuffer, LPDWORD lpdwNumBytesReturned,
|
384 |
|
|
DWORD dwTapControllerState);
|
385 |
|
|
FTC_STATUS JTAG_WriteReadDataToFromExternalDevice(FTC_HANDLE ftHandle, BOOL bInstructionTestData, DWORD dwNumBitsToWriteRead,
|
386 |
|
|
//FTC_STATUS JTAG_WriteRead(FTC_HANDLE ftHandle, BOOL bInstructionTestData, DWORD dwNumBitsToWriteRead,
|
387 |
|
|
PWriteDataByteBuffer pWriteDataBuffer, DWORD dwNumBytesToWrite,
|
388 |
|
|
PReadDataByteBuffer pReadDataBuffer, LPDWORD lpdwNumBytesReturned,
|
389 |
|
|
DWORD dwTapControllerState);
|
390 |
|
|
FTC_STATUS JTAG_GenerateTCKClockPulses(FTC_HANDLE ftHandle, DWORD dwNumClockPulses);
|
391 |
|
|
//FTC_STATUS JTAG_GenerateClockPulses(FTC_HANDLE ftHandle, DWORD dwNumClockPulses);
|
392 |
|
|
FTC_STATUS JTAG_ClearCommandSequence(void);
|
393 |
|
|
//FTC_STATUS JTAG_ClearCmdSequence(void);
|
394 |
|
|
FTC_STATUS JTAG_AddWriteCommand(BOOL bInstructionTestData, DWORD dwNumBitsToWrite,
|
395 |
|
|
//FTC_STATUS JTAG_AddWriteCmd(BOOL bInstructionTestData, DWORD dwNumBitsToWrite,
|
396 |
|
|
PWriteDataByteBuffer pWriteDataBuffer, DWORD dwNumBytesToWrite,
|
397 |
|
|
DWORD dwTapControllerState);
|
398 |
|
|
FTC_STATUS JTAG_AddReadCommand(BOOL bInstructionTestData, DWORD dwNumBitsToRead, DWORD dwTapControllerState);
|
399 |
|
|
//FTC_STATUS JTAG_AddReadCmd(BOOL bInstructionTestData, DWORD dwNumBitsToRead, DWORD dwTapControllerState);
|
400 |
|
|
FTC_STATUS JTAG_AddWriteReadCommand(BOOL bInstructionTestData, DWORD dwNumBitsToWriteRead,
|
401 |
|
|
//FTC_STATUS JTAG_AddWriteReadCmd(BOOL bInstructionTestData, DWORD dwNumBitsToWriteRead,
|
402 |
|
|
PWriteDataByteBuffer pWriteDataBuffer, DWORD dwNumBytesToWrite,
|
403 |
|
|
DWORD dwTapControllerState);
|
404 |
|
|
FTC_STATUS JTAG_ClearDeviceCommandSequence(FTC_HANDLE ftHandle);
|
405 |
|
|
//FTC_STATUS JTAG_ClearDeviceCmdSequence(FTC_HANDLE ftHandle);
|
406 |
|
|
FTC_STATUS JTAG_AddDeviceWriteCommand(FTC_HANDLE ftHandle, BOOL bInstructionTestData, DWORD dwNumBitsToWrite,
|
407 |
|
|
//FTC_STATUS JTAG_AddDeviceWriteCmd(FTC_HANDLE ftHandle, BOOL bInstructionTestData, DWORD dwNumBitsToWrite,
|
408 |
|
|
PWriteDataByteBuffer pWriteDataBuffer, DWORD dwNumBytesToWrite,
|
409 |
|
|
DWORD dwTapControllerState);
|
410 |
|
|
FTC_STATUS JTAG_AddDeviceReadCommand(FTC_HANDLE ftHandle, BOOL bInstructionTestData, DWORD dwNumBitsToRead, DWORD dwTapControllerState);
|
411 |
|
|
//FTC_STATUS JTAG_AddDeviceReadCmd(FTC_HANDLE ftHandle, BOOL bInstructionTestData, DWORD dwNumBitsToRead, DWORD dwTapControllerState);
|
412 |
|
|
FTC_STATUS JTAG_AddDeviceWriteReadCommand(FTC_HANDLE ftHandle, BOOL bInstructionTestData, DWORD dwNumBitsToWriteRead,
|
413 |
|
|
//FTC_STATUS JTAG_AddDeviceWriteReadCmd(FTC_HANDLE ftHandle, BOOL bInstructionTestData, DWORD dwNumBitsToWriteRead,
|
414 |
|
|
PWriteDataByteBuffer pWriteDataBuffer, DWORD dwNumBytesToWrite,
|
415 |
|
|
DWORD dwTapControllerState);
|
416 |
|
|
FTC_STATUS JTAG_ExecuteCommandSequence(FTC_HANDLE ftHandle, PReadCmdSequenceDataByteBuffer pReadCmdSequenceDataBuffer,
|
417 |
|
|
//FTC_STATUS JTAG_ExecuteCmdSequence(FTC_HANDLE ftHandle, PReadCmdSequenceDataByteBuffer pReadCmdSequenceDataBuffer,
|
418 |
|
|
LPDWORD lpdwNumBytesReturned);
|
419 |
|
|
FTC_STATUS JTAG_GetDllVersion(LPSTR lpDllVersionBuffer, DWORD dwBufferSize);
|
420 |
|
|
FTC_STATUS JTAG_GetErrorCodeString(LPSTR lpLanguage, FTC_STATUS StatusCode,
|
421 |
|
|
LPSTR lpErrorMessageBuffer, DWORD dwBufferSize);
|
422 |
|
|
};
|
423 |
|
|
|
424 |
|
|
#endif /* FT2232cMpsseJtag_H */
|