Code Review / openocd.git / blob
? search:


4239c2d0bd10b93821b8cafef506375b34b2cb76
[openocd.git] / src / jtag / ft2232.c
1 /***************************************************************************
2 * Copyright (C) 2004, 2006 by Dominic Rath *
3 * Dominic.Rath@gmx.de *
4 * *
5 * Copyright (C) 2008 by Spencer Oliver *
6 * spen@spen-soft.co.uk *
7 * *
8 * Copyright (C) 2009 by SoftPLC Corporation. http://softplc.com *
9 * Dick Hollenbeck <dick@softplc.com> *
10 * *
11 * This program is free software; you can redistribute it and/or modify *
12 * it under the terms of the GNU General Public License as published by *
13 * the Free Software Foundation; either version 2 of the License, or *
14 * (at your option) any later version. *
15 * *
16 * This program is distributed in the hope that it will be useful, *
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
19 * GNU General Public License for more details. *
20 * *
21 * You should have received a copy of the GNU General Public License *
22 * along with this program; if not, write to the *
23 * Free Software Foundation, Inc., *
24 * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
25 ***************************************************************************/
26
27
28 /* This code uses information contained in the MPSSE specification which was
29 * found here:
30 * http://www.ftdichip.com/Documents/AppNotes/AN2232C-01_MPSSE_Cmnd.pdf
31 * Hereafter this is called the "MPSSE Spec".
32 *
33 * The datasheet for the ftdichip.com's FT2232D part is here:
34 * http://www.ftdichip.com/Documents/DataSheets/DS_FT2232D.pdf
35 */
36
37
38 #ifdef HAVE_CONFIG_H
39 #include "config.h"
40 #endif
41
42 /* project specific includes */
43 #include "jtag.h"
44 #include "time_support.h"
45
46 #if IS_CYGWIN == 1
47 #include <windows.h>
48 #endif
49
50 #include <assert.h>
51
52 #if (BUILD_FT2232_FTD2XX==1 && BUILD_FT2232_LIBFTDI==1)
53 #error "BUILD_FT2232_FTD2XX && BUILD_FT2232_LIBFTDI are mutually exclusive"
54 #elif(BUILD_FT2232_FTD2XX!=1 && BUILD_FT2232_LIBFTDI!=1)
55 #error "BUILD_FT2232_FTD2XX || BUILD_FT2232_LIBFTDI must be chosen"
56 #endif
57
58 /* FT2232 access library includes */
59 #if BUILD_FT2232_FTD2XX == 1
60 #include <ftd2xx.h>
61 #elif BUILD_FT2232_LIBFTDI == 1
62 #include <ftdi.h>
63 #endif
64
65 /* max TCK for the high speed devices 30000 kHz */
66 #define FTDI_2232H_4232H_MAX_TCK 30000
67
68 static int ft2232_execute_queue(void);
69
70 static int ft2232_speed(int speed);
71 static int ft2232_speed_div(int speed, int* khz);
72 static int ft2232_khz(int khz, int* jtag_speed);
73 static int ft2232_register_commands(struct command_context_s* cmd_ctx);
74 static int ft2232_init(void);
75 static int ft2232_quit(void);
76
77 static int ft2232_handle_device_desc_command(struct command_context_s* cmd_ctx, char* cmd, char** args, int argc);
78 static int ft2232_handle_serial_command(struct command_context_s* cmd_ctx, char* cmd, char** args, int argc);
79 static int ft2232_handle_layout_command(struct command_context_s* cmd_ctx, char* cmd, char** args, int argc);
80 static int ft2232_handle_vid_pid_command(struct command_context_s* cmd_ctx, char* cmd, char** args, int argc);
81 static int ft2232_handle_latency_command(struct command_context_s* cmd_ctx, char* cmd, char** args, int argc);
82
83
84 /**
85 * Function ft2232_stableclocks
86 * will send out \a num_cycles on the TCK line while the TAP(s)
87 * are in a stable state. Calling code must ensure that current state is
88 * stable, that verification is not done in here.
89 * @param num_cycles is the count of clocks cycles to send.
90 * @return int - ERROR_OK or ERROR_JTAG_QUEUE_FAILED
91 */
92 static int ft2232_stableclocks(int num_cycles, jtag_command_t* cmd);
93
94
95 static char * ft2232_device_desc_A = NULL;
96 static char* ft2232_device_desc = NULL;
97 static char* ft2232_serial = NULL;
98 static char* ft2232_layout = NULL;
99 static u8 ft2232_latency = 2;
100 static unsigned ft2232_max_tck = 6000;
101
102
103 #define MAX_USB_IDS 8
104 /* vid = pid = 0 marks the end of the list */
105 static u16 ft2232_vid[MAX_USB_IDS + 1] = { 0x0403, 0 };
106 static u16 ft2232_pid[MAX_USB_IDS + 1] = { 0x6010, 0 };
107
108 typedef struct ft2232_layout_s
109 {
110 char* name;
111 int (*init)(void);
112 void (*reset)(int trst, int srst);
113 void (*blink)(void);
114 } ft2232_layout_t;
115
116 /* init procedures for supported layouts */
117 static int usbjtag_init(void);
118 static int jtagkey_init(void);
119 static int olimex_jtag_init(void);
120 static int flyswatter_init(void);
121 static int turtle_init(void);
122 static int comstick_init(void);
123 static int stm32stick_init(void);
124 static int axm0432_jtag_init(void);
125 static int sheevaplug_init(void);
126 static int icebear_jtag_init(void);
127
128 /* reset procedures for supported layouts */
129 static void usbjtag_reset(int trst, int srst);
130 static void jtagkey_reset(int trst, int srst);
131 static void olimex_jtag_reset(int trst, int srst);
132 static void flyswatter_reset(int trst, int srst);
133 static void turtle_reset(int trst, int srst);
134 static void comstick_reset(int trst, int srst);
135 static void stm32stick_reset(int trst, int srst);
136 static void axm0432_jtag_reset(int trst, int srst);
137 static void sheevaplug_reset(int trst, int srst);
138 static void icebear_jtag_reset(int trst, int srst);
139
140 /* blink procedures for layouts that support a blinking led */
141 static void olimex_jtag_blink(void);
142 static void flyswatter_jtag_blink(void);
143 static void turtle_jtag_blink(void);
144
145 ft2232_layout_t ft2232_layouts[] =
146 {
147 { "usbjtag", usbjtag_init, usbjtag_reset, NULL },
148 { "jtagkey", jtagkey_init, jtagkey_reset, NULL },
149 { "jtagkey_prototype_v1", jtagkey_init, jtagkey_reset, NULL },
150 { "oocdlink", jtagkey_init, jtagkey_reset, NULL },
151 { "signalyzer", usbjtag_init, usbjtag_reset, NULL },
152 { "evb_lm3s811", usbjtag_init, usbjtag_reset, NULL },
153 { "olimex-jtag", olimex_jtag_init, olimex_jtag_reset, olimex_jtag_blink },
154 { "flyswatter", flyswatter_init, flyswatter_reset, flyswatter_jtag_blink },
155 { "turtelizer2", turtle_init, turtle_reset, turtle_jtag_blink },
156 { "comstick", comstick_init, comstick_reset, NULL },
157 { "stm32stick", stm32stick_init, stm32stick_reset, NULL },
158 { "axm0432_jtag", axm0432_jtag_init, axm0432_jtag_reset, NULL },
159 {"sheevaplug", sheevaplug_init, sheevaplug_reset, NULL },
160 { "icebear", icebear_jtag_init, icebear_jtag_reset, NULL },
161 { NULL, NULL, NULL, NULL },
162 };
163
164 static u8 nTRST, nTRSTnOE, nSRST, nSRSTnOE;
165
166 static ft2232_layout_t* layout;
167 static u8 low_output = 0x0;
168 static u8 low_direction = 0x0;
169 static u8 high_output = 0x0;
170 static u8 high_direction = 0x0;
171
172 #if BUILD_FT2232_FTD2XX == 1
173 static FT_HANDLE ftdih = NULL;
174 #elif BUILD_FT2232_LIBFTDI == 1
175 static struct ftdi_context ftdic;
176 #endif
177
178
179 static jtag_command_t* first_unsent; /* next command that has to be sent */
180 static int require_send;
181
182
183 /* http://urjtag.wiki.sourceforge.net/Cable+FT2232 says:
184
185 "There is a significant difference between libftdi and libftd2xx. The latter
186 one allows to schedule up to 64*64 bytes of result data while libftdi fails
187 with more than 4*64. As a consequence, the FT2232 driver is forced to
188 perform around 16x more USB transactions for long command streams with TDO
189 capture when running with libftdi."
190
191 No idea how we get
192 #define FT2232_BUFFER_SIZE 131072
193 a comment would have been nice.
194 */
195
196 #define FT2232_BUFFER_SIZE 131072
197
198 static u8* ft2232_buffer = NULL;
199 static int ft2232_buffer_size = 0;
200 static int ft2232_read_pointer = 0;
201 static int ft2232_expect_read = 0;
202
203 /**
204 * Function buffer_write
205 * writes a byte into the byte buffer, "ft2232_buffer", which must be sent later.
206 * @param val is the byte to send.
207 */
208 static inline void buffer_write( u8 val )
209 {
210 assert( ft2232_buffer );
211 assert( (unsigned) ft2232_buffer_size < (unsigned) FT2232_BUFFER_SIZE );
212 ft2232_buffer[ft2232_buffer_size++] = val;
213 }
214
215 /**
216 * Function buffer_read
217 * returns a byte from the byte buffer.
218 */
219 static inline u8 buffer_read(void)
220 {
221 assert( ft2232_buffer );
222 assert( ft2232_read_pointer < ft2232_buffer_size );
223 return ft2232_buffer[ft2232_read_pointer++];
224 }
225
226
227 /**
228 * Function clock_tms
229 * clocks out \a bit_count bits on the TMS line, starting with the least
230 * significant bit of tms_bits and progressing to more significant bits.
231 * Rigorous state transition logging is done here via tap_set_state().
232 *
233 * @param pmsse_cmd is one of the MPSSE TMS oriented commands such as 0x4b or 0x6b. See
234 * the MPSSE spec referenced above for their functionality. The MPSSE command
235 * "Clock Data to TMS/CS Pin (no Read)" is often used for this, 0x4b.
236 *
237 * @param tms_bits holds the sequence of bits to send.
238 * @param tms_count tells how many bits in the sequence.
239 * @param tdi_bit is a single bit which is passed on to TDI before the first TCK cycle
240 * and is held static for the duration of TMS clocking. See the MPSSE spec referenced above.
241 */
242 static void clock_tms( u8 mpsse_cmd, int tms_bits, int tms_count, bool tdi_bit )
243 {
244 u8 tms_byte;
245 int i;
246 int tms_ndx; /* bit index into tms_byte */
247
248 assert( tms_count > 0 );
249
250 // LOG_DEBUG("mpsse cmd=%02x, tms_bits=0x%08x, bit_count=%d", mpsse_cmd, tms_bits, tms_count );
251
252 for (tms_byte = tms_ndx = i = 0; i < tms_count; ++i, tms_bits>>=1)
253 {
254 bool bit = tms_bits & 1;
255
256 if(bit)
257 tms_byte |= (1<<tms_ndx);
258
259 /* always do state transitions in public view */
260 tap_set_state( tap_state_transition(tap_get_state(), bit) );
261
262 /* we wrote a bit to tms_byte just above, increment bit index. if bit was zero
263 also increment.
264 */
265 ++tms_ndx;
266
267 if( tms_ndx==7 || i==tms_count-1 )
268 {
269 buffer_write( mpsse_cmd );
270 buffer_write( tms_ndx - 1 );
271
272 /* Bit 7 of the byte is passed on to TDI/DO before the first TCK/SK of
273 TMS/CS and is held static for the duration of TMS/CS clocking.
274 */
275 buffer_write( tms_byte | (tdi_bit << 7) );
276 }
277 }
278 }
279
280
281 /**
282 * Function get_tms_buffer_requirements
283 * returns what clock_tms() will consume if called with
284 * same \a bit_count.
285 */
286 static inline int get_tms_buffer_requirements( int bit_count )
287 {
288 return ((bit_count + 6)/7) * 3;
289 }
290
291
292 /**
293 * Function move_to_state
294 * moves the TAP controller from the current state to a
295 * \a goal_state through a path given by tap_get_tms_path(). State transition
296 * logging is performed by delegation to clock_tms().
297 *
298 * @param goal_state is the destination state for the move.
299 */
300 static void move_to_state( tap_state_t goal_state )
301 {
302 tap_state_t start_state = tap_get_state();
303
304 /* goal_state is 1/2 of a tuple/pair of states which allow convenient
305 lookup of the required TMS pattern to move to this state from the
306 start state.
307 */
308
309 /* do the 2 lookups */
310 int tms_bits = tap_get_tms_path(start_state, goal_state);
311 int tms_count = tap_get_tms_path_len(start_state, goal_state);
312
313 DEBUG_JTAG_IO( "start=%s goal=%s", tap_state_name(start_state), tap_state_name(goal_state) );
314
315 clock_tms( 0x4b, tms_bits, tms_count, 0 );
316 }
317
318
319 jtag_interface_t ft2232_interface =
320 {
321 .name = "ft2232",
322 .execute_queue = ft2232_execute_queue,
323 .speed = ft2232_speed,
324 .speed_div = ft2232_speed_div,
325 .khz = ft2232_khz,
326 .register_commands = ft2232_register_commands,
327 .init = ft2232_init,
328 .quit = ft2232_quit,
329 };
330
331 static int ft2232_write(u8* buf, int size, u32* bytes_written)
332 {
333 #if BUILD_FT2232_FTD2XX == 1
334 FT_STATUS status;
335 DWORD dw_bytes_written;
336 if ( ( status = FT_Write(ftdih, buf, size, &dw_bytes_written) ) != FT_OK )
337 {
338 *bytes_written = dw_bytes_written;
339 LOG_ERROR("FT_Write returned: %lu", status);
340 return ERROR_JTAG_DEVICE_ERROR;
341 }
342 else
343 {
344 *bytes_written = dw_bytes_written;
345 return ERROR_OK;
346 }
347 #elif BUILD_FT2232_LIBFTDI == 1
348 int retval;
349 if ( ( retval = ftdi_write_data(&ftdic, buf, size) ) < 0 )
350 {
351 *bytes_written = 0;
352 LOG_ERROR( "ftdi_write_data: %s", ftdi_get_error_string(&ftdic) );
353 return ERROR_JTAG_DEVICE_ERROR;
354 }
355 else
356 {
357 *bytes_written = retval;
358 return ERROR_OK;
359 }
360 #endif
361 }
362
363
364 static int ft2232_read(u8* buf, u32 size, u32* bytes_read)
365 {
366 #if BUILD_FT2232_FTD2XX == 1
367 DWORD dw_bytes_read;
368 FT_STATUS status;
369 int timeout = 5;
370 *bytes_read = 0;
371
372 while ( (*bytes_read < size) && timeout-- )
373 {
374 if ( ( status = FT_Read(ftdih, buf + *bytes_read, size -
375 *bytes_read, &dw_bytes_read) ) != FT_OK )
376 {
377 *bytes_read = 0;
378 LOG_ERROR("FT_Read returned: %lu", status);
379 return ERROR_JTAG_DEVICE_ERROR;
380 }
381 *bytes_read += dw_bytes_read;
382 }
383
384 #elif BUILD_FT2232_LIBFTDI == 1
385 int retval;
386 int timeout = 100;
387 *bytes_read = 0;
388
389 while ( (*bytes_read < size) && timeout-- )
390 {
391 if ( ( retval = ftdi_read_data(&ftdic, buf + *bytes_read, size - *bytes_read) ) < 0 )
392 {
393 *bytes_read = 0;
394 LOG_ERROR( "ftdi_read_data: %s", ftdi_get_error_string(&ftdic) );
395 return ERROR_JTAG_DEVICE_ERROR;
396 }
397 *bytes_read += retval;
398 }
399
400 #endif
401
402 if (*bytes_read < size)
403 {
404 LOG_ERROR("couldn't read the requested number of bytes from FT2232 device (%i < %i)", *bytes_read, size);
405 return ERROR_JTAG_DEVICE_ERROR;
406 }
407
408 return ERROR_OK;
409 }
410
411
412 static int ft2232_speed(int speed)
413 {
414 u8 buf[3];
415 int retval;
416 u32 bytes_written;
417
418 buf[0] = 0x86; /* command "set divisor" */
419 buf[1] = speed & 0xff; /* valueL (0=6MHz, 1=3MHz, 2=2.0MHz, ...*/
420 buf[2] = (speed >> 8) & 0xff; /* valueH */
421
422 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
423 if ( ( ( retval = ft2232_write(buf, 3, &bytes_written) ) != ERROR_OK ) || (bytes_written != 3) )
424 {
425 LOG_ERROR("couldn't set FT2232 TCK speed");
426 return retval;
427 }
428
429 return ERROR_OK;
430 }
431
432
433 static int ft2232_speed_div(int speed, int* khz)
434 {
435 /* Take a look in the FT2232 manual,
436 * AN2232C-01 Command Processor for
437 * MPSSE and MCU Host Bus. Chapter 3.8 */
438
439 *khz = ft2232_max_tck / (1 + speed);
440
441 return ERROR_OK;
442 }
443
444
445 static int ft2232_khz(int khz, int* jtag_speed)
446 {
447 if (khz==0)
448 {
449 LOG_DEBUG("RTCK not supported");
450 return ERROR_FAIL;
451 }
452
453 /* Take a look in the FT2232 manual,
454 * AN2232C-01 Command Processor for
455 * MPSSE and MCU Host Bus. Chapter 3.8
456 *
457 * We will calc here with a multiplier
458 * of 10 for better rounding later. */
459
460 /* Calc speed, (ft2232_max_tck / khz) - 1 */
461 /* Use 65000 for better rounding */
462 *jtag_speed = ((ft2232_max_tck*10) / khz) - 10;
463
464 /* Add 0.9 for rounding */
465 *jtag_speed += 9;
466
467 /* Calc real speed */
468 *jtag_speed = *jtag_speed / 10;
469
470 /* Check if speed is greater than 0 */
471 if (*jtag_speed < 0)
472 {
473 *jtag_speed = 0;
474 }
475
476 /* Check max value */
477 if (*jtag_speed > 0xFFFF)
478 {
479 *jtag_speed = 0xFFFF;
480 }
481
482 return ERROR_OK;
483 }
484
485
486 static int ft2232_register_commands(struct command_context_s* cmd_ctx)
487 {
488 register_command(cmd_ctx, NULL, "ft2232_device_desc", ft2232_handle_device_desc_command,
489 COMMAND_CONFIG, "the USB device description of the FTDI FT2232 device");
490 register_command(cmd_ctx, NULL, "ft2232_serial", ft2232_handle_serial_command,
491 COMMAND_CONFIG, "the serial number of the FTDI FT2232 device");
492 register_command(cmd_ctx, NULL, "ft2232_layout", ft2232_handle_layout_command,
493 COMMAND_CONFIG, "the layout of the FT2232 GPIO signals used to control output-enables and reset signals");
494 register_command(cmd_ctx, NULL, "ft2232_vid_pid", ft2232_handle_vid_pid_command,
495 COMMAND_CONFIG, "the vendor ID and product ID of the FTDI FT2232 device");
496 register_command(cmd_ctx, NULL, "ft2232_latency", ft2232_handle_latency_command,
497 COMMAND_CONFIG, "set the FT2232 latency timer to a new value");
498 return ERROR_OK;
499 }
500
501
502 void ft2232_end_state(tap_state_t state)
503 {
504 if (tap_is_state_stable(state))
505 tap_set_end_state(state);
506 else
507 {
508 LOG_ERROR("BUG: %s is not a stable end state", tap_state_name(state));
509 exit(-1);
510 }
511 }
512
513
514 static void ft2232_read_scan(enum scan_type type, u8* buffer, int scan_size)
515 {
516 int num_bytes = (scan_size + 7) / 8;
517 int bits_left = scan_size;
518 int cur_byte = 0;
519
520 while (num_bytes-- > 1)
521 {
522 buffer[cur_byte++] = buffer_read();
523 bits_left -= 8;
524 }
525
526 buffer[cur_byte] = 0x0;
527
528 /* There is one more partial byte left from the clock data in/out instructions */
529 if (bits_left > 1)
530 {
531 buffer[cur_byte] = buffer_read() >> 1;
532 }
533 /* This shift depends on the length of the clock data to tms instruction, insterted at end of the scan, now fixed to a two step transition in ft2232_add_scan */
534 buffer[cur_byte] = ( buffer[cur_byte] | ( ( (buffer_read()) << 1 ) & 0x80 )) >> (8 - bits_left);
535 }
536
537
538 static void ft2232_debug_dump_buffer(void)
539 {
540 int i;
541 char line[256];
542 char* line_p = line;
543
544 for (i = 0; i < ft2232_buffer_size; i++)
545 {
546 line_p += snprintf(line_p, 256 - (line_p - line), "%2.2x ", ft2232_buffer[i]);
547 if (i % 16 == 15)
548 {
549 LOG_DEBUG("%s", line);
550 line_p = line;
551 }
552 }
553
554 if (line_p != line)
555 LOG_DEBUG("%s", line);
556 }
557
558
559 static int ft2232_send_and_recv(jtag_command_t* first, jtag_command_t* last)
560 {
561 jtag_command_t* cmd;
562 u8* buffer;
563 int scan_size;
564 enum scan_type type;
565 int retval;
566 u32 bytes_written=0;
567 u32 bytes_read=0;
568
569 #ifdef _DEBUG_USB_IO_
570 struct timeval start, inter, inter2, end;
571 struct timeval d_inter, d_inter2, d_end;
572 #endif
573
574 #ifdef _DEBUG_USB_COMMS_
575 LOG_DEBUG("write buffer (size %i):", ft2232_buffer_size);
576 ft2232_debug_dump_buffer();
577 #endif
578
579 #ifdef _DEBUG_USB_IO_
580 gettimeofday(&start, NULL);
581 #endif
582
583 if ( ( retval = ft2232_write(ft2232_buffer, ft2232_buffer_size, &bytes_written) ) != ERROR_OK )
584 {
585 LOG_ERROR("couldn't write MPSSE commands to FT2232");
586 return retval;
587 }
588
589 #ifdef _DEBUG_USB_IO_
590 gettimeofday(&inter, NULL);
591 #endif
592
593 if (ft2232_expect_read)
594 {
595 int timeout = 100;
596 ft2232_buffer_size = 0;
597
598 #ifdef _DEBUG_USB_IO_
599 gettimeofday(&inter2, NULL);
600 #endif
601
602 if ( ( retval = ft2232_read(ft2232_buffer, ft2232_expect_read, &bytes_read) ) != ERROR_OK )
603 {
604 LOG_ERROR("couldn't read from FT2232");
605 return retval;
606 }
607
608 #ifdef _DEBUG_USB_IO_
609 gettimeofday(&end, NULL);
610
611 timeval_subtract(&d_inter, &inter, &start);
612 timeval_subtract(&d_inter2, &inter2, &start);
613 timeval_subtract(&d_end, &end, &start);
614
615 LOG_INFO("inter: %u.%06u, inter2: %u.%06u end: %u.%06u",
616 (unsigned)d_inter.tv_sec, (unsigned)d_inter.tv_usec,
617 (unsigned)d_inter2.tv_sec, (unsigned)d_inter2.tv_usec,
618 (unsigned)d_end.tv_sec, (unsigned)d_end.tv_usec);
619 #endif
620
621 ft2232_buffer_size = bytes_read;
622
623 if (ft2232_expect_read != ft2232_buffer_size)
624 {
625 LOG_ERROR("ft2232_expect_read (%i) != ft2232_buffer_size (%i) (%i retries)", ft2232_expect_read,
626 ft2232_buffer_size,
627 100 - timeout);
628 ft2232_debug_dump_buffer();
629
630 exit(-1);
631 }
632
633 #ifdef _DEBUG_USB_COMMS_
634 LOG_DEBUG("read buffer (%i retries): %i bytes", 100 - timeout, ft2232_buffer_size);
635 ft2232_debug_dump_buffer();
636 #endif
637 }
638
639 ft2232_expect_read = 0;
640 ft2232_read_pointer = 0;
641
642 /* return ERROR_OK, unless a jtag_read_buffer returns a failed check
643 * that wasn't handled by a caller-provided error handler
644 */
645 retval = ERROR_OK;
646
647 cmd = first;
648 while (cmd != last)
649 {
650 switch (cmd->type)
651 {
652 case JTAG_SCAN:
653 type = jtag_scan_type(cmd->cmd.scan);
654 if (type != SCAN_OUT)
655 {
656 scan_size = jtag_scan_size(cmd->cmd.scan);
657 buffer = calloc(CEIL(scan_size, 8), 1);
658 ft2232_read_scan(type, buffer, scan_size);
659 if (jtag_read_buffer(buffer, cmd->cmd.scan) != ERROR_OK)
660 retval = ERROR_JTAG_QUEUE_FAILED;
661 free(buffer);
662 }
663 break;
664
665 default:
666 break;
667 }
668
669 cmd = cmd->next;
670 }
671
672 ft2232_buffer_size = 0;
673
674 return retval;
675 }
676
677
678 /**
679 * Function ft2232_add_pathmove
680 * moves the TAP controller from the current state to a new state through the
681 * given path, where path is an array of tap_state_t's.
682 *
683 * @param path is an array of tap_stat_t which gives the states to traverse through
684 * ending with the last state at path[num_states-1]
685 * @param num_states is the count of state steps to move through
686 */
687 static void ft2232_add_pathmove( tap_state_t* path, int num_states )
688 {
689 int tms_bits = 0;
690 int state_ndx;
691 tap_state_t walker = tap_get_state();
692
693 assert( (unsigned) num_states <= 32u ); /* tms_bits only holds 32 bits */
694
695 /* this loop verifies that the path is legal and logs each state in the path */
696 for( state_ndx = 0; state_ndx < num_states; ++state_ndx )
697 {
698 tap_state_t desired_next_state = path[state_ndx];
699
700 if (tap_state_transition(walker, false) == desired_next_state )
701 ; /* bit within tms_bits at index state_ndx is already zero */
702 else if (tap_state_transition(walker, true) == desired_next_state )
703 tms_bits |= (1<<state_ndx);
704 else
705 {
706 LOG_ERROR( "BUG: %s -> %s isn't a valid TAP transition",
707 tap_state_name(walker), tap_state_name(desired_next_state) );
708 exit(-1);
709 }
710
711 walker = desired_next_state;
712 }
713
714 clock_tms( 0x4b, tms_bits, num_states, 0 );
715
716 tap_set_end_state(tap_get_state());
717 }
718
719
720 void ft2232_add_scan(bool ir_scan, enum scan_type type, u8* buffer, int scan_size)
721 {
722 int num_bytes = (scan_size + 7) / 8;
723 int bits_left = scan_size;
724 int cur_byte = 0;
725 int last_bit;
726
727 if ( !ir_scan )
728 {
729 if (tap_get_state() != TAP_DRSHIFT)
730 {
731 move_to_state( TAP_DRSHIFT );
732 }
733 }
734 else
735 {
736 if (tap_get_state() != TAP_IRSHIFT)
737 {
738 move_to_state( TAP_IRSHIFT );
739 }
740 }
741
742 /* add command for complete bytes */
743 while (num_bytes > 1)
744 {
745 int thisrun_bytes;
746 if (type == SCAN_IO)
747 {
748 /* Clock Data Bytes In and Out LSB First */
749 buffer_write( 0x39 );
750 /* LOG_DEBUG("added TDI bytes (io %i)", num_bytes); */
751 }
752 else if (type == SCAN_OUT)
753 {
754 /* Clock Data Bytes Out on -ve Clock Edge LSB First (no Read) */
755 buffer_write( 0x19 );
756 /* LOG_DEBUG("added TDI bytes (o)"); */
757 }
758 else if (type == SCAN_IN)
759 {
760 /* Clock Data Bytes In on +ve Clock Edge LSB First (no Write) */
761 buffer_write( 0x28 );
762 /* LOG_DEBUG("added TDI bytes (i %i)", num_bytes); */
763 }
764
765 thisrun_bytes = (num_bytes > 65537) ? 65536 : (num_bytes - 1);
766 num_bytes -= thisrun_bytes;
767
768 buffer_write( (u8) (thisrun_bytes - 1) );
769 buffer_write( (u8) ((thisrun_bytes - 1) >> 8) );
770
771 if (type != SCAN_IN)
772 {
773 /* add complete bytes */
774 while (thisrun_bytes-- > 0)
775 {
776 buffer_write( buffer[cur_byte++] );
777 bits_left -= 8;
778 }
779 }
780 else /* (type == SCAN_IN) */
781 {
782 bits_left -= 8 * (thisrun_bytes);
783 }
784 }
785
786 /* the most signifcant bit is scanned during TAP movement */
787 if (type != SCAN_IN)
788 last_bit = ( buffer[cur_byte] >> (bits_left - 1) ) & 0x1;
789 else
790 last_bit = 0;
791
792 /* process remaining bits but the last one */
793 if (bits_left > 1)
794 {
795 if (type == SCAN_IO)
796 {
797 /* Clock Data Bits In and Out LSB First */
798 buffer_write( 0x3b );
799 /* LOG_DEBUG("added TDI bits (io) %i", bits_left - 1); */
800 }
801 else if (type == SCAN_OUT)
802 {
803 /* Clock Data Bits Out on -ve Clock Edge LSB First (no Read) */
804 buffer_write( 0x1b );
805 /* LOG_DEBUG("added TDI bits (o)"); */
806 }
807 else if (type == SCAN_IN)
808 {
809 /* Clock Data Bits In on +ve Clock Edge LSB First (no Write) */
810 buffer_write( 0x2a );
811 /* LOG_DEBUG("added TDI bits (i %i)", bits_left - 1); */
812 }
813
814 buffer_write( bits_left - 2 );
815 if (type != SCAN_IN)
816 buffer_write( buffer[cur_byte] );
817 }
818
819 if ( ( ir_scan && (tap_get_end_state() == TAP_IRSHIFT) )
820 || ( !ir_scan && (tap_get_end_state() == TAP_DRSHIFT) ) )
821 {
822 if (type == SCAN_IO)
823 {
824 /* Clock Data Bits In and Out LSB First */
825 buffer_write( 0x3b );
826 /* LOG_DEBUG("added TDI bits (io) %i", bits_left - 1); */
827 }
828 else if (type == SCAN_OUT)
829 {
830 /* Clock Data Bits Out on -ve Clock Edge LSB First (no Read) */
831 buffer_write( 0x1b );
832 /* LOG_DEBUG("added TDI bits (o)"); */
833 }
834 else if (type == SCAN_IN)
835 {
836 /* Clock Data Bits In on +ve Clock Edge LSB First (no Write) */
837 buffer_write( 0x2a );
838 /* LOG_DEBUG("added TDI bits (i %i)", bits_left - 1); */
839 }
840 buffer_write( 0x0 );
841 buffer_write( last_bit );
842 }
843 else
844 {
845 int tms_bits;
846 int tms_count;
847 u8 mpsse_cmd;
848
849 /* move from Shift-IR/DR to end state */
850 if (type != SCAN_OUT)
851 {
852 /* We always go to the PAUSE state in two step at the end of an IN or IO scan */
853 /* This must be coordinated with the bit shifts in ft2232_read_scan */
854 tms_bits = 0x01;
855 tms_count = 2;
856 /* Clock Data to TMS/CS Pin with Read */
857 mpsse_cmd = 0x6b;
858 /* LOG_DEBUG("added TMS scan (read)"); */
859 }
860 else
861 {
862 tms_bits = tap_get_tms_path( tap_get_state(), tap_get_end_state() );
863 tms_count = tap_get_tms_path_len( tap_get_state(), tap_get_end_state() );
864 /* Clock Data to TMS/CS Pin (no Read) */
865 mpsse_cmd = 0x4b;
866 /* LOG_DEBUG("added TMS scan (no read)"); */
867 }
868
869 clock_tms( mpsse_cmd, tms_bits, tms_count, last_bit );
870 }
871
872 if (tap_get_state() != tap_get_end_state())
873 {
874 move_to_state( tap_get_end_state() );
875 }
876 }
877
878
879 static int ft2232_large_scan(scan_command_t* cmd, enum scan_type type, u8* buffer, int scan_size)
880 {
881 int num_bytes = (scan_size + 7) / 8;
882 int bits_left = scan_size;
883 int cur_byte = 0;
884 int last_bit;
885 u8* receive_buffer = malloc( CEIL(scan_size, 8) );
886 u8* receive_pointer = receive_buffer;
887 u32 bytes_written;
888 u32 bytes_read;
889 int retval;
890 int thisrun_read = 0;
891
892 if (cmd->ir_scan)
893 {
894 LOG_ERROR("BUG: large IR scans are not supported");
895 exit(-1);
896 }
897
898 if (tap_get_state() != TAP_DRSHIFT)
899 {
900 move_to_state( TAP_DRSHIFT );
901 }
902
903 if ( ( retval = ft2232_write(ft2232_buffer, ft2232_buffer_size, &bytes_written) ) != ERROR_OK )
904 {
905 LOG_ERROR("couldn't write MPSSE commands to FT2232");
906 exit(-1);
907 }
908 LOG_DEBUG("ft2232_buffer_size: %i, bytes_written: %i", ft2232_buffer_size, bytes_written);
909 ft2232_buffer_size = 0;
910
911 /* add command for complete bytes */
912 while (num_bytes > 1)
913 {
914 int thisrun_bytes;
915
916 if (type == SCAN_IO)
917 {
918 /* Clock Data Bytes In and Out LSB First */
919 buffer_write( 0x39 );
920 /* LOG_DEBUG("added TDI bytes (io %i)", num_bytes); */
921 }
922 else if (type == SCAN_OUT)
923 {
924 /* Clock Data Bytes Out on -ve Clock Edge LSB First (no Read) */
925 buffer_write( 0x19 );
926 /* LOG_DEBUG("added TDI bytes (o)"); */
927 }
928 else if (type == SCAN_IN)
929 {
930 /* Clock Data Bytes In on +ve Clock Edge LSB First (no Write) */
931 buffer_write( 0x28 );
932 /* LOG_DEBUG("added TDI bytes (i %i)", num_bytes); */
933 }
934
935 thisrun_bytes = (num_bytes > 65537) ? 65536 : (num_bytes - 1);
936 thisrun_read = thisrun_bytes;
937 num_bytes -= thisrun_bytes;
938 buffer_write( (u8) (thisrun_bytes - 1) );
939 buffer_write( (u8) ( (thisrun_bytes - 1) >> 8 ));
940
941 if (type != SCAN_IN)
942 {
943 /* add complete bytes */
944 while (thisrun_bytes-- > 0)
945 {
946 buffer_write( buffer[cur_byte] );
947 cur_byte++;
948 bits_left -= 8;
949 }
950 }
951 else /* (type == SCAN_IN) */
952 {
953 bits_left -= 8 * (thisrun_bytes);
954 }
955
956 if ( ( retval = ft2232_write(ft2232_buffer, ft2232_buffer_size, &bytes_written) ) != ERROR_OK )
957 {
958 LOG_ERROR("couldn't write MPSSE commands to FT2232");
959 exit(-1);
960 }
961 LOG_DEBUG("ft2232_buffer_size: %i, bytes_written: %i", ft2232_buffer_size, bytes_written);
962 ft2232_buffer_size = 0;
963
964 if (type != SCAN_OUT)
965 {
966 if ( ( retval = ft2232_read(receive_pointer, thisrun_read, &bytes_read) ) != ERROR_OK )
967 {
968 LOG_ERROR("couldn't read from FT2232");
969 exit(-1);
970 }
971 LOG_DEBUG("thisrun_read: %i, bytes_read: %i", thisrun_read, bytes_read);
972 receive_pointer += bytes_read;
973 }
974 }
975
976 thisrun_read = 0;
977
978 /* the most signifcant bit is scanned during TAP movement */
979 if (type != SCAN_IN)
980 last_bit = ( buffer[cur_byte] >> (bits_left - 1) ) & 0x1;
981 else
982 last_bit = 0;
983
984 /* process remaining bits but the last one */
985 if (bits_left > 1)
986 {
987 if (type == SCAN_IO)
988 {
989 /* Clock Data Bits In and Out LSB First */
990 buffer_write( 0x3b );
991 /* LOG_DEBUG("added TDI bits (io) %i", bits_left - 1); */
992 }
993 else if (type == SCAN_OUT)
994 {
995 /* Clock Data Bits Out on -ve Clock Edge LSB First (no Read) */
996 buffer_write( 0x1b );
997 /* LOG_DEBUG("added TDI bits (o)"); */
998 }
999 else if (type == SCAN_IN)
1000 {
1001 /* Clock Data Bits In on +ve Clock Edge LSB First (no Write) */
1002 buffer_write( 0x2a );
1003 /* LOG_DEBUG("added TDI bits (i %i)", bits_left - 1); */
1004 }
1005 buffer_write( bits_left - 2 );
1006 if (type != SCAN_IN)
1007 buffer_write( buffer[cur_byte] );
1008
1009 if (type != SCAN_OUT)
1010 thisrun_read += 2;
1011 }
1012
1013 if (tap_get_end_state() == TAP_DRSHIFT)
1014 {
1015 if (type == SCAN_IO)
1016 {
1017 /* Clock Data Bits In and Out LSB First */
1018 buffer_write( 0x3b );
1019 /* LOG_DEBUG("added TDI bits (io) %i", bits_left - 1); */
1020 }
1021 else if (type == SCAN_OUT)
1022 {
1023 /* Clock Data Bits Out on -ve Clock Edge LSB First (no Read) */
1024 buffer_write( 0x1b );
1025 /* LOG_DEBUG("added TDI bits (o)"); */
1026 }
1027 else if (type == SCAN_IN)
1028 {
1029 /* Clock Data Bits In on +ve Clock Edge LSB First (no Write) */
1030 buffer_write( 0x2a );
1031 /* LOG_DEBUG("added TDI bits (i %i)", bits_left - 1); */
1032 }
1033 buffer_write( 0x0 );
1034 buffer_write( last_bit );
1035 }
1036 else
1037 {
1038 int tms_bits = tap_get_tms_path( tap_get_state(), tap_get_end_state() );
1039 int tms_count = tap_get_tms_path_len( tap_get_state(), tap_get_end_state() );
1040 u8 mpsse_cmd;
1041
1042 /* move from Shift-IR/DR to end state */
1043 if (type != SCAN_OUT)
1044 {
1045 /* Clock Data to TMS/CS Pin with Read */
1046 mpsse_cmd = 0x6b;
1047 /* LOG_DEBUG("added TMS scan (read)"); */
1048 }
1049 else
1050 {
1051 /* Clock Data to TMS/CS Pin (no Read) */
1052 mpsse_cmd = 0x4b;
1053 /* LOG_DEBUG("added TMS scan (no read)"); */
1054 }
1055
1056 clock_tms( mpsse_cmd, tms_bits, tms_count, last_bit );
1057 }
1058
1059 if (type != SCAN_OUT)
1060 thisrun_read += 1;
1061
1062 if ( ( retval = ft2232_write(ft2232_buffer, ft2232_buffer_size, &bytes_written) ) != ERROR_OK )
1063 {
1064 LOG_ERROR("couldn't write MPSSE commands to FT2232");
1065 exit(-1);
1066 }
1067 LOG_DEBUG("ft2232_buffer_size: %i, bytes_written: %i", ft2232_buffer_size, bytes_written);
1068 ft2232_buffer_size = 0;
1069
1070 if (type != SCAN_OUT)
1071 {
1072 if ( ( retval = ft2232_read(receive_pointer, thisrun_read, &bytes_read) ) != ERROR_OK )
1073 {
1074 LOG_ERROR("couldn't read from FT2232");
1075 exit(-1);
1076 }
1077 LOG_DEBUG("thisrun_read: %i, bytes_read: %i", thisrun_read, bytes_read);
1078 receive_pointer += bytes_read;
1079 }
1080
1081 return ERROR_OK;
1082 }
1083
1084
1085 static int ft2232_predict_scan_out(int scan_size, enum scan_type type)
1086 {
1087 int predicted_size = 3;
1088 int num_bytes = (scan_size - 1) / 8;
1089
1090 if (tap_get_state() != TAP_DRSHIFT)
1091 predicted_size += get_tms_buffer_requirements( tap_get_tms_path_len( tap_get_state(), TAP_DRSHIFT) );
1092
1093 if (type == SCAN_IN) /* only from device to host */
1094 {
1095 /* complete bytes */
1096 predicted_size += CEIL(num_bytes, 65536) * 3;
1097
1098 /* remaining bits - 1 (up to 7) */
1099 predicted_size += ( (scan_size - 1) % 8 ) ? 2 : 0;
1100 }
1101 else /* host to device, or bidirectional */
1102 {
1103 /* complete bytes */
1104 predicted_size += num_bytes + CEIL(num_bytes, 65536) * 3;
1105
1106 /* remaining bits -1 (up to 7) */
1107 predicted_size += ( (scan_size - 1) % 8 ) ? 3 : 0;
1108 }
1109
1110 return predicted_size;
1111 }
1112
1113
1114 static int ft2232_predict_scan_in(int scan_size, enum scan_type type)
1115 {
1116 int predicted_size = 0;
1117
1118 if (type != SCAN_OUT)
1119 {
1120 /* complete bytes */
1121 predicted_size += (CEIL(scan_size, 8) > 1) ? (CEIL(scan_size, 8) - 1) : 0;
1122
1123 /* remaining bits - 1 */
1124 predicted_size += ( (scan_size - 1) % 8 ) ? 1 : 0;
1125
1126 /* last bit (from TMS scan) */
1127 predicted_size += 1;
1128 }
1129
1130 /* LOG_DEBUG("scan_size: %i, predicted_size: %i", scan_size, predicted_size); */
1131
1132 return predicted_size;
1133 }
1134
1135
1136 static void usbjtag_reset(int trst, int srst)
1137 {
1138 if (trst == 1)
1139 {
1140 if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
1141 low_direction |= nTRSTnOE; /* switch to output pin (output is low) */
1142 else
1143 low_output &= ~nTRST; /* switch output low */
1144 }
1145 else if (trst == 0)
1146 {
1147 if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
1148 low_direction &= ~nTRSTnOE; /* switch to input pin (high-Z + internal and external pullup) */
1149 else
1150 low_output |= nTRST; /* switch output high */
1151 }
1152
1153 if (srst == 1)
1154 {
1155 if (jtag_reset_config & RESET_SRST_PUSH_PULL)
1156 low_output &= ~nSRST; /* switch output low */
1157 else
1158 low_direction |= nSRSTnOE; /* switch to output pin (output is low) */
1159 }
1160 else if (srst == 0)
1161 {
1162 if (jtag_reset_config & RESET_SRST_PUSH_PULL)
1163 low_output |= nSRST; /* switch output high */
1164 else
1165 low_direction &= ~nSRSTnOE; /* switch to input pin (high-Z) */
1166 }
1167
1168 /* command "set data bits low byte" */
1169 buffer_write( 0x80 );
1170 buffer_write( low_output );
1171 buffer_write( low_direction );
1172 }
1173
1174
1175 static void jtagkey_reset(int trst, int srst)
1176 {
1177 if (trst == 1)
1178 {
1179 if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
1180 high_output &= ~nTRSTnOE;
1181 else
1182 high_output &= ~nTRST;
1183 }
1184 else if (trst == 0)
1185 {
1186 if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
1187 high_output |= nTRSTnOE;
1188 else
1189 high_output |= nTRST;
1190 }
1191
1192 if (srst == 1)
1193 {
1194 if (jtag_reset_config & RESET_SRST_PUSH_PULL)
1195 high_output &= ~nSRST;
1196 else
1197 high_output &= ~nSRSTnOE;
1198 }
1199 else if (srst == 0)
1200 {
1201 if (jtag_reset_config & RESET_SRST_PUSH_PULL)
1202 high_output |= nSRST;
1203 else
1204 high_output |= nSRSTnOE;
1205 }
1206
1207 /* command "set data bits high byte" */
1208 buffer_write( 0x82 );
1209 buffer_write( high_output );
1210 buffer_write( high_direction );
1211 LOG_DEBUG("trst: %i, srst: %i, high_output: 0x%2.2x, high_direction: 0x%2.2x", trst, srst, high_output,
1212 high_direction);
1213 }
1214
1215
1216 static void olimex_jtag_reset(int trst, int srst)
1217 {
1218 if (trst == 1)
1219 {
1220 if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
1221 high_output &= ~nTRSTnOE;
1222 else
1223 high_output &= ~nTRST;
1224 }
1225 else if (trst == 0)
1226 {
1227 if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
1228 high_output |= nTRSTnOE;
1229 else
1230 high_output |= nTRST;
1231 }
1232
1233 if (srst == 1)
1234 {
1235 high_output |= nSRST;
1236 }
1237 else if (srst == 0)
1238 {
1239 high_output &= ~nSRST;
1240 }
1241
1242 /* command "set data bits high byte" */
1243 buffer_write( 0x82 );
1244 buffer_write( high_output );
1245 buffer_write( high_direction );
1246 LOG_DEBUG("trst: %i, srst: %i, high_output: 0x%2.2x, high_direction: 0x%2.2x", trst, srst, high_output,
1247 high_direction);
1248 }
1249
1250
1251 static void axm0432_jtag_reset(int trst, int srst)
1252 {
1253 if (trst == 1)
1254 {
1255 tap_set_state(TAP_RESET);
1256 high_output &= ~nTRST;
1257 }
1258 else if (trst == 0)
1259 {
1260 high_output |= nTRST;
1261 }
1262
1263 if (srst == 1)
1264 {
1265 high_output &= ~nSRST;
1266 }
1267 else if (srst == 0)
1268 {
1269 high_output |= nSRST;
1270 }
1271
1272 /* command "set data bits low byte" */
1273 buffer_write( 0x82 );
1274 buffer_write( high_output );
1275 buffer_write( high_direction );
1276 LOG_DEBUG("trst: %i, srst: %i, high_output: 0x%2.2x, high_direction: 0x%2.2x", trst, srst, high_output,
1277 high_direction);
1278 }
1279
1280
1281 static void flyswatter_reset(int trst, int srst)
1282 {
1283 if (trst == 1)
1284 {
1285 low_output &= ~nTRST;
1286 }
1287 else if (trst == 0)
1288 {
1289 low_output |= nTRST;
1290 }
1291
1292 if (srst == 1)
1293 {
1294 low_output |= nSRST;
1295 }
1296 else if (srst == 0)
1297 {
1298 low_output &= ~nSRST;
1299 }
1300
1301 /* command "set data bits low byte" */
1302 buffer_write( 0x80 );
1303 buffer_write( low_output );
1304 buffer_write( low_direction );
1305 LOG_DEBUG("trst: %i, srst: %i, low_output: 0x%2.2x, low_direction: 0x%2.2x", trst, srst, low_output, low_direction);
1306 }
1307
1308
1309 static void turtle_reset(int trst, int srst)
1310 {
1311 trst = trst;
1312
1313 if (srst == 1)
1314 {
1315 low_output |= nSRST;
1316 }
1317 else if (srst == 0)
1318 {
1319 low_output &= ~nSRST;
1320 }
1321
1322 /* command "set data bits low byte" */
1323 buffer_write( 0x80 );
1324 buffer_write( low_output );
1325 buffer_write( low_direction );
1326 LOG_DEBUG("srst: %i, low_output: 0x%2.2x, low_direction: 0x%2.2x", srst, low_output, low_direction);
1327 }
1328
1329
1330 static void comstick_reset(int trst, int srst)
1331 {
1332 if (trst == 1)
1333 {
1334 high_output &= ~nTRST;
1335 }
1336 else if (trst == 0)
1337 {
1338 high_output |= nTRST;
1339 }
1340
1341 if (srst == 1)
1342 {
1343 high_output &= ~nSRST;
1344 }
1345 else if (srst == 0)
1346 {
1347 high_output |= nSRST;
1348 }
1349
1350 /* command "set data bits high byte" */
1351 buffer_write( 0x82 );
1352 buffer_write( high_output );
1353 buffer_write( high_direction );
1354 LOG_DEBUG("trst: %i, srst: %i, high_output: 0x%2.2x, high_direction: 0x%2.2x", trst, srst, high_output,
1355 high_direction);
1356 }
1357
1358
1359 static void stm32stick_reset(int trst, int srst)
1360 {
1361 if (trst == 1)
1362 {
1363 high_output &= ~nTRST;
1364 }
1365 else if (trst == 0)
1366 {
1367 high_output |= nTRST;
1368 }
1369
1370 if (srst == 1)
1371 {
1372 low_output &= ~nSRST;
1373 }
1374 else if (srst == 0)
1375 {
1376 low_output |= nSRST;
1377 }
1378
1379 /* command "set data bits low byte" */
1380 buffer_write( 0x80 );
1381 buffer_write( low_output );
1382 buffer_write( low_direction );
1383
1384 /* command "set data bits high byte" */
1385 buffer_write( 0x82 );
1386 buffer_write( high_output );
1387 buffer_write( high_direction );
1388 LOG_DEBUG("trst: %i, srst: %i, high_output: 0x%2.2x, high_direction: 0x%2.2x", trst, srst, high_output,
1389 high_direction);
1390 }
1391
1392
1393
1394 static void sheevaplug_reset(int trst, int srst)
1395 {
1396 if (trst == 1)
1397 high_output &= ~nTRST;
1398 else if (trst == 0)
1399 high_output |= nTRST;
1400
1401 if (srst == 1)
1402 high_output &= ~nSRSTnOE;
1403 else if (srst == 0)
1404 high_output |= nSRSTnOE;
1405
1406 /* command "set data bits high byte" */
1407 buffer_write( 0x82 );
1408 buffer_write( high_output );
1409 buffer_write( high_direction );
1410 LOG_DEBUG("trst: %i, srst: %i, high_output: 0x%2.2x, high_direction: 0x%2.2x", trst, srst, high_output, high_direction);
1411 }
1412
1413 static int ft2232_execute_end_state(jtag_command_t *cmd)
1414 {
1415 int retval;
1416 retval = ERROR_OK;
1417
1418 DEBUG_JTAG_IO("execute_end_state: %s", tap_state_name(cmd->cmd.end_state->end_state) );
1419
1420 if (cmd->cmd.end_state->end_state != TAP_INVALID)
1421 ft2232_end_state(cmd->cmd.end_state->end_state);
1422
1423 return retval;
1424 }
1425
1426
1427 static int ft2232_execute_runtest(jtag_command_t *cmd)
1428 {
1429 int retval;
1430 int i;
1431 int predicted_size = 0;
1432 retval = ERROR_OK;
1433
1434 DEBUG_JTAG_IO("runtest %i cycles, end in %s",
1435 cmd->cmd.runtest->num_cycles,
1436 tap_state_name(cmd->cmd.runtest->end_state));
1437
1438 /* only send the maximum buffer size that FT2232C can handle */
1439 predicted_size = 0;
1440 if (tap_get_state() != TAP_IDLE)
1441 predicted_size += 3;
1442 predicted_size += 3 * CEIL(cmd->cmd.runtest->num_cycles, 7);
1443 if ( (cmd->cmd.runtest->end_state != TAP_INVALID) && (cmd->cmd.runtest->end_state != TAP_IDLE) )
1444 predicted_size += 3;
1445 if ( (cmd->cmd.runtest->end_state == TAP_INVALID) && (tap_get_end_state() != TAP_IDLE) )
1446 predicted_size += 3;
1447 if (ft2232_buffer_size + predicted_size + 1 > FT2232_BUFFER_SIZE)
1448 {
1449 if (ft2232_send_and_recv(first_unsent, cmd) != ERROR_OK)
1450 retval = ERROR_JTAG_QUEUE_FAILED;
1451 require_send = 0;
1452 first_unsent = cmd;
1453 }
1454 if (tap_get_state() != TAP_IDLE)
1455 {
1456 move_to_state( TAP_IDLE );
1457 require_send = 1;
1458 }
1459 i = cmd->cmd.runtest->num_cycles;
1460 while (i > 0)
1461 {
1462 /* there are no state transitions in this code, so omit state tracking */
1463
1464 /* command "Clock Data to TMS/CS Pin (no Read)" */
1465 buffer_write( 0x4b );
1466
1467 /* scan 7 bits */
1468 buffer_write( (i > 7) ? 6 : (i - 1) );
1469
1470 /* TMS data bits */
1471 buffer_write( 0x0 );
1472 tap_set_state(TAP_IDLE);
1473
1474 i -= (i > 7) ? 7 : i;
1475 /* LOG_DEBUG("added TMS scan (no read)"); */
1476 }
1477
1478 if (cmd->cmd.runtest->end_state != TAP_INVALID)
1479 ft2232_end_state(cmd->cmd.runtest->end_state);
1480
1481 if ( tap_get_state() != tap_get_end_state() )
1482 {
1483 move_to_state( tap_get_end_state() );
1484 }
1485
1486 require_send = 1;
1487 #ifdef _DEBUG_JTAG_IO_
1488 LOG_DEBUG( "runtest: %i, end in %s", cmd->cmd.runtest->num_cycles, tap_state_name( tap_get_end_state() ) );
1489 #endif
1490
1491 return retval;
1492 }
1493
1494
1495 static int ft2232_execute_statemove(jtag_command_t *cmd)
1496 {
1497 int predicted_size = 0;
1498 int retval = ERROR_OK;
1499
1500 DEBUG_JTAG_IO("statemove end in %i", cmd->cmd.statemove->end_state);
1501
1502 /* only send the maximum buffer size that FT2232C can handle */
1503 predicted_size = 3;
1504 if (ft2232_buffer_size + predicted_size + 1 > FT2232_BUFFER_SIZE)
1505 {
1506 if (ft2232_send_and_recv(first_unsent, cmd) != ERROR_OK)
1507 retval = ERROR_JTAG_QUEUE_FAILED;
1508 require_send = 0;
1509 first_unsent = cmd;
1510 }
1511 if (cmd->cmd.statemove->end_state != TAP_INVALID)
1512 ft2232_end_state(cmd->cmd.statemove->end_state);
1513
1514 /* move to end state */
1515 if ( tap_get_state() != tap_get_end_state() )
1516 {
1517 move_to_state( tap_get_end_state() );
1518 require_send = 1;
1519 }
1520
1521 return retval;
1522 }
1523
1524 static int ft2232_execute_pathmove(jtag_command_t *cmd)
1525 {
1526 int predicted_size = 0;
1527 int retval = ERROR_OK;
1528
1529 tap_state_t* path = cmd->cmd.pathmove->path;
1530 int num_states = cmd->cmd.pathmove->num_states;
1531
1532 DEBUG_JTAG_IO("pathmove: %i states, current: %s end: %s", num_states,
1533 tap_state_name( tap_get_state() ),
1534 tap_state_name( path[num_states-1] )
1535 );
1536
1537 /* only send the maximum buffer size that FT2232C can handle */
1538 predicted_size = 3 * CEIL(num_states, 7);
1539 if (ft2232_buffer_size + predicted_size + 1 > FT2232_BUFFER_SIZE)
1540 {
1541 if (ft2232_send_and_recv(first_unsent, cmd) != ERROR_OK)
1542 retval = ERROR_JTAG_QUEUE_FAILED;
1543
1544 require_send = 0;
1545 first_unsent = cmd;
1546 }
1547
1548 ft2232_add_pathmove( path, num_states );
1549 require_send = 1;
1550
1551 return retval;
1552 }
1553
1554
1555 static int ft2232_execute_scan(jtag_command_t *cmd)
1556 {
1557 u8* buffer;
1558 int scan_size; /* size of IR or DR scan */
1559 int predicted_size = 0;
1560 int retval = ERROR_OK;
1561
1562 enum scan_type type = jtag_scan_type(cmd->cmd.scan);
1563
1564 DEBUG_JTAG_IO( "%s type:%d", cmd->cmd.scan->ir_scan ? "IRSCAN" : "DRSCAN", type );
1565
1566 scan_size = jtag_build_buffer(cmd->cmd.scan, &buffer);
1567
1568 predicted_size = ft2232_predict_scan_out(scan_size, type);
1569 if ( (predicted_size + 1) > FT2232_BUFFER_SIZE )
1570 {
1571 LOG_DEBUG("oversized ft2232 scan (predicted_size > FT2232_BUFFER_SIZE)");
1572 /* unsent commands before this */
1573 if (first_unsent != cmd)
1574 if (ft2232_send_and_recv(first_unsent, cmd) != ERROR_OK)
1575 retval = ERROR_JTAG_QUEUE_FAILED;
1576
1577 /* current command */
1578 if (cmd->cmd.scan->end_state != TAP_INVALID)
1579 ft2232_end_state(cmd->cmd.scan->end_state);
1580 ft2232_large_scan(cmd->cmd.scan, type, buffer, scan_size);
1581 require_send = 0;
1582 first_unsent = cmd->next;
1583 if (buffer)
1584 free(buffer);
1585 return retval;
1586 }
1587 else if (ft2232_buffer_size + predicted_size + 1 > FT2232_BUFFER_SIZE)
1588 {
1589 LOG_DEBUG("ft2232 buffer size reached, sending queued commands (first_unsent: %p, cmd: %p)",
1590 first_unsent,
1591 cmd);
1592 if (ft2232_send_and_recv(first_unsent, cmd) != ERROR_OK)
1593 retval = ERROR_JTAG_QUEUE_FAILED;
1594 require_send = 0;
1595 first_unsent = cmd;
1596 }
1597 ft2232_expect_read += ft2232_predict_scan_in(scan_size, type);
1598 /* LOG_DEBUG("new read size: %i", ft2232_expect_read); */
1599 if (cmd->cmd.scan->end_state != TAP_INVALID)
1600 ft2232_end_state(cmd->cmd.scan->end_state);
1601 ft2232_add_scan(cmd->cmd.scan->ir_scan, type, buffer, scan_size);
1602 require_send = 1;
1603 if (buffer)
1604 free(buffer);
1605 #ifdef _DEBUG_JTAG_IO_
1606 LOG_DEBUG( "%s scan, %i bits, end in %s", (cmd->cmd.scan->ir_scan) ? "IR" : "DR", scan_size,
1607 tap_state_name( tap_get_end_state() ) );
1608 #endif
1609 return retval;
1610
1611 }
1612
1613 static int ft2232_execute_reset(jtag_command_t *cmd)
1614 {
1615 int retval;
1616 int predicted_size = 0;
1617 retval = ERROR_OK;
1618
1619 DEBUG_JTAG_IO("reset trst: %i srst %i",
1620 cmd->cmd.reset->trst, cmd->cmd.reset->srst);
1621
1622 /* only send the maximum buffer size that FT2232C can handle */
1623 predicted_size = 3;
1624 if (ft2232_buffer_size + predicted_size + 1 > FT2232_BUFFER_SIZE)
1625 {
1626 if (ft2232_send_and_recv(first_unsent, cmd) != ERROR_OK)
1627 retval = ERROR_JTAG_QUEUE_FAILED;
1628 require_send = 0;
1629 first_unsent = cmd;
1630 }
1631
1632 layout->reset(cmd->cmd.reset->trst, cmd->cmd.reset->srst);
1633 require_send = 1;
1634
1635 #ifdef _DEBUG_JTAG_IO_
1636 LOG_DEBUG("trst: %i, srst: %i", cmd->cmd.reset->trst, cmd->cmd.reset->srst);
1637 #endif
1638 return retval;
1639 }
1640
1641 static int ft2232_execute_sleep(jtag_command_t *cmd)
1642 {
1643 int retval;
1644 retval = ERROR_OK;
1645
1646 DEBUG_JTAG_IO("sleep %i", cmd->cmd.sleep->us);
1647
1648 if (ft2232_send_and_recv(first_unsent, cmd) != ERROR_OK)
1649 retval = ERROR_JTAG_QUEUE_FAILED;
1650 first_unsent = cmd->next;
1651 jtag_sleep(cmd->cmd.sleep->us);
1652 #ifdef _DEBUG_JTAG_IO_
1653 LOG_DEBUG( "sleep %i usec while in %s", cmd->cmd.sleep->us, tap_state_name( tap_get_state() ) );
1654 #endif
1655
1656 return retval;
1657 }
1658
1659 static int ft2232_execute_stableclocks(jtag_command_t *cmd)
1660 {
1661 int retval;
1662 retval = ERROR_OK;
1663
1664 /* this is only allowed while in a stable state. A check for a stable
1665 * state was done in jtag_add_clocks()
1666 */
1667 if (ft2232_stableclocks(cmd->cmd.stableclocks->num_cycles, cmd) != ERROR_OK)
1668 retval = ERROR_JTAG_QUEUE_FAILED;
1669 #ifdef _DEBUG_JTAG_IO_
1670 LOG_DEBUG( "clocks %i while in %s", cmd->cmd.stableclocks->num_cycles, tap_state_name( tap_get_state() ) );
1671 #endif
1672
1673 return retval;
1674 }
1675
1676 static int ft2232_execute_command(jtag_command_t *cmd)
1677 {
1678 int retval;
1679 retval = ERROR_OK;
1680
1681 switch (cmd->type)
1682 {
1683 case JTAG_END_STATE: retval = ft2232_execute_end_state(cmd); break;
1684 case JTAG_RESET: retval = ft2232_execute_reset(cmd); break;
1685 case JTAG_RUNTEST: retval = ft2232_execute_runtest(cmd); break;
1686 case JTAG_STATEMOVE: retval = ft2232_execute_statemove(cmd); break;
1687 case JTAG_PATHMOVE: retval = ft2232_execute_pathmove(cmd); break;
1688 case JTAG_SCAN: retval = ft2232_execute_scan(cmd); break;
1689 case JTAG_SLEEP: retval = ft2232_execute_sleep(cmd); break;
1690 case JTAG_STABLECLOCKS: retval = ft2232_execute_stableclocks(cmd); break;
1691 default:
1692 LOG_ERROR("BUG: unknown JTAG command type encountered");
1693 exit(-1);
1694 }
1695 return retval;
1696 }
1697
1698 static int ft2232_execute_queue()
1699 {
1700 jtag_command_t* cmd = jtag_command_queue; /* currently processed command */
1701 int retval;
1702
1703 first_unsent = cmd; /* next command that has to be sent */
1704 require_send = 0;
1705
1706 /* return ERROR_OK, unless ft2232_send_and_recv reports a failed check
1707 * that wasn't handled by a caller-provided error handler
1708 */
1709 retval = ERROR_OK;
1710
1711 ft2232_buffer_size = 0;
1712 ft2232_expect_read = 0;
1713
1714 /* blink, if the current layout has that feature */
1715 if (layout->blink)
1716 layout->blink();
1717
1718 while (cmd)
1719 {
1720 if (ft2232_execute_command(cmd) != ERROR_OK)
1721 retval = ERROR_JTAG_QUEUE_FAILED;
1722 /* Start reading input before FT2232 TX buffer fills up */
1723 cmd = cmd->next;
1724 if (ft2232_expect_read > 256)
1725 {
1726 if (ft2232_send_and_recv(first_unsent, cmd) != ERROR_OK)
1727 retval = ERROR_JTAG_QUEUE_FAILED;
1728 first_unsent = cmd;
1729 }
1730 }
1731
1732 if (require_send > 0)
1733 if (ft2232_send_and_recv(first_unsent, cmd) != ERROR_OK)
1734 retval = ERROR_JTAG_QUEUE_FAILED;
1735
1736 return retval;
1737 }
1738
1739
1740 #if BUILD_FT2232_FTD2XX == 1
1741 static int ft2232_init_ftd2xx(u16 vid, u16 pid, int more, int* try_more)
1742 {
1743 FT_STATUS status;
1744 DWORD openex_flags = 0;
1745 char* openex_string = NULL;
1746 u8 latency_timer;
1747
1748 LOG_DEBUG("'ft2232' interface using FTD2XX with '%s' layout (%4.4x:%4.4x)", ft2232_layout, vid, pid);
1749
1750 #if IS_WIN32 == 0
1751 /* Add non-standard Vid/Pid to the linux driver */
1752 if ( ( status = FT_SetVIDPID(vid, pid) ) != FT_OK )
1753 {
1754 LOG_WARNING("couldn't add %4.4x:%4.4x", vid, pid);
1755 }
1756 #endif
1757
1758 if (ft2232_device_desc && ft2232_serial)
1759 {
1760 LOG_WARNING("can't open by device description and serial number, giving precedence to serial");
1761 ft2232_device_desc = NULL;
1762 }
1763
1764 if (ft2232_device_desc)
1765 {
1766 openex_string = ft2232_device_desc;
1767 openex_flags = FT_OPEN_BY_DESCRIPTION;
1768 }
1769 else if (ft2232_serial)
1770 {
1771 openex_string = ft2232_serial;
1772 openex_flags = FT_OPEN_BY_SERIAL_NUMBER;
1773 }
1774 else
1775 {
1776 LOG_ERROR("neither device description nor serial number specified");
1777 LOG_ERROR("please add \"ft2232_device_desc <string>\" or \"ft2232_serial <string>\" to your .cfg file");
1778
1779 return ERROR_JTAG_INIT_FAILED;
1780 }
1781
1782 status = FT_OpenEx(openex_string, openex_flags, &ftdih);
1783 if( status != FT_OK ){
1784 // under Win32, the FTD2XX driver appends an "A" to the end
1785 // of the description, if we tried by the desc, then
1786 // try by the alternate "A" description.
1787 if( openex_string == ft2232_device_desc ){
1788 // Try the alternate method.
1789 openex_string = ft2232_device_desc_A;
1790 status = FT_OpenEx(openex_string, openex_flags, &ftdih);
1791 if( status == FT_OK ){
1792 // yea, the "alternate" method worked!
1793 } else {
1794 // drat, give the user a meaningfull message.
1795 // telling the use we tried *BOTH* methods.
1796 LOG_WARNING("Unable to open FTDI Device tried: '%s' and '%s'\n",
1797 ft2232_device_desc,
1798 ft2232_device_desc_A );
1799 }
1800 }
1801 }
1802
1803 if ( status != FT_OK )
1804 {
1805 DWORD num_devices;
1806
1807 if (more)
1808 {
1809 LOG_WARNING("unable to open ftdi device (trying more): %lu", status);
1810 *try_more = 1;
1811 return ERROR_JTAG_INIT_FAILED;
1812 }
1813 LOG_ERROR("unable to open ftdi device: %lu", status);
1814 status = FT_ListDevices(&num_devices, NULL, FT_LIST_NUMBER_ONLY);
1815 if (status == FT_OK)
1816 {
1817 char** desc_array = malloc( sizeof(char*) * (num_devices + 1) );
1818 u32 i;
1819
1820 for (i = 0; i < num_devices; i++)
1821 desc_array[i] = malloc(64);
1822
1823 desc_array[num_devices] = NULL;
1824
1825 status = FT_ListDevices(desc_array, &num_devices, FT_LIST_ALL | openex_flags);
1826
1827 if (status == FT_OK)
1828 {
1829 LOG_ERROR("ListDevices: %lu\n", num_devices);
1830 for (i = 0; i < num_devices; i++)
1831 LOG_ERROR("%i: \"%s\"", i, desc_array[i]);
1832 }
1833
1834 for (i = 0; i < num_devices; i++)
1835 free(desc_array[i]);
1836
1837 free(desc_array);
1838 }
1839 else
1840 {
1841 LOG_ERROR("ListDevices: NONE\n");
1842 }
1843 return ERROR_JTAG_INIT_FAILED;
1844 }
1845
1846 if ( ( status = FT_SetLatencyTimer(ftdih, ft2232_latency) ) != FT_OK )
1847 {
1848 LOG_ERROR("unable to set latency timer: %lu", status);
1849 return ERROR_JTAG_INIT_FAILED;
1850 }
1851
1852 if ( ( status = FT_GetLatencyTimer(ftdih, &latency_timer) ) != FT_OK )
1853 {
1854 LOG_ERROR("unable to get latency timer: %lu", status);
1855 return ERROR_JTAG_INIT_FAILED;
1856 }
1857 else
1858 {
1859 LOG_DEBUG("current latency timer: %i", latency_timer);
1860 }
1861
1862 if ( ( status = FT_SetTimeouts(ftdih, 5000, 5000) ) != FT_OK )
1863 {
1864 LOG_ERROR("unable to set timeouts: %lu", status);
1865 return ERROR_JTAG_INIT_FAILED;
1866 }
1867
1868 if ( ( status = FT_SetBitMode(ftdih, 0x0b, 2) ) != FT_OK )
1869 {
1870 LOG_ERROR("unable to enable bit i/o mode: %lu", status);
1871 return ERROR_JTAG_INIT_FAILED;
1872 }
1873
1874 return ERROR_OK;
1875 }
1876
1877
1878 static int ft2232_purge_ftd2xx(void)
1879 {
1880 FT_STATUS status;
1881
1882 if ( ( status = FT_Purge(ftdih, FT_PURGE_RX | FT_PURGE_TX) ) != FT_OK )
1883 {
1884 LOG_ERROR("error purging ftd2xx device: %lu", status);
1885 return ERROR_JTAG_INIT_FAILED;
1886 }
1887
1888 return ERROR_OK;
1889 }
1890
1891
1892 #endif /* BUILD_FT2232_FTD2XX == 1 */
1893
1894 #if BUILD_FT2232_LIBFTDI == 1
1895 static int ft2232_init_libftdi(u16 vid, u16 pid, int more, int* try_more)
1896 {
1897 u8 latency_timer;
1898
1899 LOG_DEBUG("'ft2232' interface using libftdi with '%s' layout (%4.4x:%4.4x)",
1900 ft2232_layout, vid, pid);
1901
1902 if (ftdi_init(&ftdic) < 0)
1903 return ERROR_JTAG_INIT_FAILED;
1904
1905 if (ftdi_set_interface(&ftdic, INTERFACE_A) < 0)
1906 {
1907 LOG_ERROR("unable to select FT2232 channel A: %s", ftdic.error_str);
1908 return ERROR_JTAG_INIT_FAILED;
1909 }
1910
1911 /* context, vendor id, product id */
1912 if (ftdi_usb_open_desc(&ftdic, vid, pid, ft2232_device_desc,
1913 ft2232_serial) < 0)
1914 {
1915 if (more)
1916 LOG_WARNING("unable to open ftdi device (trying more): %s",
1917 ftdic.error_str);
1918 else
1919 LOG_ERROR("unable to open ftdi device: %s", ftdic.error_str);
1920 *try_more = 1;
1921 return ERROR_JTAG_INIT_FAILED;
1922 }
1923
1924 /* There is already a reset in ftdi_usb_open_desc, this should be redundant */
1925 if (ftdi_usb_reset(&ftdic) < 0)
1926 {
1927 LOG_ERROR("unable to reset ftdi device");
1928 return ERROR_JTAG_INIT_FAILED;
1929 }
1930
1931 if (ftdi_set_latency_timer(&ftdic, ft2232_latency) < 0)
1932 {
1933 LOG_ERROR("unable to set latency timer");
1934 return ERROR_JTAG_INIT_FAILED;
1935 }
1936
1937 if (ftdi_get_latency_timer(&ftdic, &latency_timer) < 0)
1938 {
1939 LOG_ERROR("unable to get latency timer");
1940 return ERROR_JTAG_INIT_FAILED;
1941 }
1942 else
1943 {
1944 LOG_DEBUG("current latency timer: %i", latency_timer);
1945 }
1946
1947 ftdi_set_bitmode(&ftdic, 0x0b, 2); /* ctx, JTAG I/O mask */
1948
1949 return ERROR_OK;
1950 }
1951
1952
1953 static int ft2232_purge_libftdi(void)
1954 {
1955 if (ftdi_usb_purge_buffers(&ftdic) < 0)
1956 {
1957 LOG_ERROR("ftdi_purge_buffers: %s", ftdic.error_str);
1958 return ERROR_JTAG_INIT_FAILED;
1959 }
1960
1961 return ERROR_OK;
1962 }
1963
1964
1965 #endif /* BUILD_FT2232_LIBFTDI == 1 */
1966
1967 static int ft2232_init(void)
1968 {
1969 u8 buf[1];
1970 int retval;
1971 u32 bytes_written;
1972 ft2232_layout_t* cur_layout = ft2232_layouts;
1973 int i;
1974
1975 if (tap_get_tms_path_len(TAP_IRPAUSE,TAP_IRPAUSE)==7)
1976 {
1977 LOG_DEBUG("ft2232 interface using 7 step jtag state transitions");
1978 }
1979 else
1980 {
1981 LOG_DEBUG("ft2232 interface using shortest path jtag state transitions");
1982
1983 }
1984 if ( (ft2232_layout == NULL) || (ft2232_layout[0] == 0) )
1985 {
1986 ft2232_layout = "usbjtag";
1987 LOG_WARNING("No ft2232 layout specified, using default 'usbjtag'");
1988 }
1989
1990 while (cur_layout->name)
1991 {
1992 if (strcmp(cur_layout->name, ft2232_layout) == 0)
1993 {
1994 layout = cur_layout;
1995 break;
1996 }
1997 cur_layout++;
1998 }
1999
2000 if (!layout)
2001 {
2002 LOG_ERROR("No matching layout found for %s", ft2232_layout);
2003 return ERROR_JTAG_INIT_FAILED;
2004 }
2005
2006 for (i = 0; 1; i++)
2007 {
2008 /*
2009 * "more indicates that there are more IDs to try, so we should
2010 * not print an error for an ID mismatch (but for anything
2011 * else, we should).
2012 *
2013 * try_more indicates that the error code returned indicates an
2014 * ID mismatch (and nothing else) and that we should proceeed
2015 * with the next ID pair.
2016 */
2017 int more = ft2232_vid[i + 1] || ft2232_pid[i + 1];
2018 int try_more = 0;
2019
2020 #if BUILD_FT2232_FTD2XX == 1
2021 retval = ft2232_init_ftd2xx(ft2232_vid[i], ft2232_pid[i],
2022 more, &try_more);
2023 #elif BUILD_FT2232_LIBFTDI == 1
2024 retval = ft2232_init_libftdi(ft2232_vid[i], ft2232_pid[i],
2025 more, &try_more);
2026 #endif
2027 if (retval >= 0)
2028 break;
2029 if (!more || !try_more)
2030 return retval;
2031 }
2032
2033 ft2232_buffer_size = 0;
2034 ft2232_buffer = malloc(FT2232_BUFFER_SIZE);
2035
2036 if (layout->init() != ERROR_OK)
2037 return ERROR_JTAG_INIT_FAILED;
2038
2039 ft2232_speed(jtag_speed);
2040
2041 buf[0] = 0x85; /* Disconnect TDI/DO to TDO/DI for Loopback */
2042 if ( ( ( retval = ft2232_write(buf, 1, &bytes_written) ) != ERROR_OK ) || (bytes_written != 1) )
2043 {
2044 LOG_ERROR("couldn't write to FT2232 to disable loopback");
2045 return ERROR_JTAG_INIT_FAILED;
2046 }
2047
2048 #if BUILD_FT2232_FTD2XX == 1
2049 return ft2232_purge_ftd2xx();
2050 #elif BUILD_FT2232_LIBFTDI == 1
2051 return ft2232_purge_libftdi();
2052 #endif
2053
2054 return ERROR_OK;
2055 }
2056
2057
2058 static int usbjtag_init(void)
2059 {
2060 u8 buf[3];
2061 u32 bytes_written;
2062
2063 low_output = 0x08;
2064 low_direction = 0x0b;
2065
2066 if (strcmp(ft2232_layout, "usbjtag") == 0)
2067 {
2068 nTRST = 0x10;
2069 nTRSTnOE = 0x10;
2070 nSRST = 0x40;
2071 nSRSTnOE = 0x40;
2072 }
2073 else if (strcmp(ft2232_layout, "signalyzer") == 0)
2074 {
2075 nTRST = 0x10;
2076 nTRSTnOE = 0x10;
2077 nSRST = 0x20;
2078 nSRSTnOE = 0x20;
2079 }
2080 else if (strcmp(ft2232_layout, "evb_lm3s811") == 0)
2081 {
2082 nTRST = 0x0;
2083 nTRSTnOE = 0x00;
2084 nSRST = 0x20;
2085 nSRSTnOE = 0x20;
2086 low_output = 0x88;
2087 low_direction = 0x8b;
2088 }
2089 else
2090 {
2091 LOG_ERROR("BUG: usbjtag_init called for unknown layout '%s'", ft2232_layout);
2092 return ERROR_JTAG_INIT_FAILED;
2093 }
2094
2095 if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
2096 {
2097 low_direction &= ~nTRSTnOE; /* nTRST input */
2098 low_output &= ~nTRST; /* nTRST = 0 */
2099 }
2100 else
2101 {
2102 low_direction |= nTRSTnOE; /* nTRST output */
2103 low_output |= nTRST; /* nTRST = 1 */
2104 }
2105
2106 if (jtag_reset_config & RESET_SRST_PUSH_PULL)
2107 {
2108 low_direction |= nSRSTnOE; /* nSRST output */
2109 low_output |= nSRST; /* nSRST = 1 */
2110 }
2111 else
2112 {
2113 low_direction &= ~nSRSTnOE; /* nSRST input */
2114 low_output &= ~nSRST; /* nSRST = 0 */
2115 }
2116
2117 /* initialize low byte for jtag */
2118 buf[0] = 0x80; /* command "set data bits low byte" */
2119 buf[1] = low_output; /* value (TMS=1,TCK=0, TDI=0, xRST high) */
2120 buf[2] = low_direction; /* dir (output=1), TCK/TDI/TMS=out, TDO=in */
2121 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2122
2123 if ( ( ( ft2232_write(buf, 3, &bytes_written) ) != ERROR_OK ) || (bytes_written != 3) )
2124 {
2125 LOG_ERROR("couldn't initialize FT2232 with 'USBJTAG' layout");
2126 return ERROR_JTAG_INIT_FAILED;
2127 }
2128
2129 return ERROR_OK;
2130 }
2131
2132
2133 static int axm0432_jtag_init(void)
2134 {
2135 u8 buf[3];
2136 u32 bytes_written;
2137
2138 low_output = 0x08;
2139 low_direction = 0x2b;
2140
2141 /* initialize low byte for jtag */
2142 buf[0] = 0x80; /* command "set data bits low byte" */
2143 buf[1] = low_output; /* value (TMS=1,TCK=0, TDI=0, nOE=0) */
2144 buf[2] = low_direction; /* dir (output=1), TCK/TDI/TMS=out, TDO=in, nOE=out */
2145 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2146
2147 if ( ( ( ft2232_write(buf, 3, &bytes_written) ) != ERROR_OK ) || (bytes_written != 3) )
2148 {
2149 LOG_ERROR("couldn't initialize FT2232 with 'JTAGkey' layout");
2150 return ERROR_JTAG_INIT_FAILED;
2151 }
2152
2153 if (strcmp(layout->name, "axm0432_jtag") == 0)
2154 {
2155 nTRST = 0x08;
2156 nTRSTnOE = 0x0; /* No output enable for TRST*/
2157 nSRST = 0x04;
2158 nSRSTnOE = 0x0; /* No output enable for SRST*/
2159 }
2160 else
2161 {
2162 LOG_ERROR("BUG: axm0432_jtag_init called for non axm0432 layout");
2163 exit(-1);
2164 }
2165
2166 high_output = 0x0;
2167 high_direction = 0x0c;
2168
2169 if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
2170 {
2171 LOG_ERROR("can't set nTRSTOE to push-pull on the Dicarlo jtag");
2172 }
2173 else
2174 {
2175 high_output |= nTRST;
2176 }
2177
2178 if (jtag_reset_config & RESET_SRST_PUSH_PULL)
2179 {
2180 LOG_ERROR("can't set nSRST to push-pull on the Dicarlo jtag");
2181 }
2182 else
2183 {
2184 high_output |= nSRST;
2185 }
2186
2187 /* initialize high port */
2188 buf[0] = 0x82; /* command "set data bits high byte" */
2189 buf[1] = high_output; /* value */
2190 buf[2] = high_direction; /* all outputs (xRST and xRSTnOE) */
2191 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2192
2193 if ( ( ( ft2232_write(buf, 3, &bytes_written) ) != ERROR_OK ) || (bytes_written != 3) )
2194 {
2195 LOG_ERROR("couldn't initialize FT2232 with 'Dicarlo' layout");
2196 return ERROR_JTAG_INIT_FAILED;
2197 }
2198
2199 return ERROR_OK;
2200 }
2201
2202
2203 static int jtagkey_init(void)
2204 {
2205 u8 buf[3];
2206 u32 bytes_written;
2207
2208 low_output = 0x08;
2209 low_direction = 0x1b;
2210
2211 /* initialize low byte for jtag */
2212 buf[0] = 0x80; /* command "set data bits low byte" */
2213 buf[1] = low_output; /* value (TMS=1,TCK=0, TDI=0, nOE=0) */
2214 buf[2] = low_direction; /* dir (output=1), TCK/TDI/TMS=out, TDO=in, nOE=out */
2215 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2216
2217 if ( ( ( ft2232_write(buf, 3, &bytes_written) ) != ERROR_OK ) || (bytes_written != 3) )
2218 {
2219 LOG_ERROR("couldn't initialize FT2232 with 'JTAGkey' layout");
2220 return ERROR_JTAG_INIT_FAILED;
2221 }
2222
2223 if (strcmp(layout->name, "jtagkey") == 0)
2224 {
2225 nTRST = 0x01;
2226 nTRSTnOE = 0x4;
2227 nSRST = 0x02;
2228 nSRSTnOE = 0x08;
2229 }
2230 else if ( (strcmp(layout->name, "jtagkey_prototype_v1") == 0)
2231 || (strcmp(layout->name, "oocdlink") == 0) )
2232 {
2233 nTRST = 0x02;
2234 nTRSTnOE = 0x1;
2235 nSRST = 0x08;
2236 nSRSTnOE = 0x04;
2237 }
2238 else
2239 {
2240 LOG_ERROR("BUG: jtagkey_init called for non jtagkey layout");
2241 exit(-1);
2242 }
2243
2244 high_output = 0x0;
2245 high_direction = 0x0f;
2246
2247 if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
2248 {
2249 high_output |= nTRSTnOE;
2250 high_output &= ~nTRST;
2251 }
2252 else
2253 {
2254 high_output &= ~nTRSTnOE;
2255 high_output |= nTRST;
2256 }
2257
2258 if (jtag_reset_config & RESET_SRST_PUSH_PULL)
2259 {
2260 high_output &= ~nSRSTnOE;
2261 high_output |= nSRST;
2262 }
2263 else
2264 {
2265 high_output |= nSRSTnOE;
2266 high_output &= ~nSRST;
2267 }
2268
2269 /* initialize high port */
2270 buf[0] = 0x82; /* command "set data bits high byte" */
2271 buf[1] = high_output; /* value */
2272 buf[2] = high_direction; /* all outputs (xRST and xRSTnOE) */
2273 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2274
2275 if ( ( ( ft2232_write(buf, 3, &bytes_written) ) != ERROR_OK ) || (bytes_written != 3) )
2276 {
2277 LOG_ERROR("couldn't initialize FT2232 with 'JTAGkey' layout");
2278 return ERROR_JTAG_INIT_FAILED;
2279 }
2280
2281 return ERROR_OK;
2282 }
2283
2284
2285 static int olimex_jtag_init(void)
2286 {
2287 u8 buf[3];
2288 u32 bytes_written;
2289
2290 low_output = 0x08;
2291 low_direction = 0x1b;
2292
2293 /* initialize low byte for jtag */
2294 buf[0] = 0x80; /* command "set data bits low byte" */
2295 buf[1] = low_output; /* value (TMS=1,TCK=0, TDI=0, nOE=0) */
2296 buf[2] = low_direction; /* dir (output=1), TCK/TDI/TMS=out, TDO=in, nOE=out */
2297 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2298
2299 if ( ( ( ft2232_write(buf, 3, &bytes_written) ) != ERROR_OK ) || (bytes_written != 3) )
2300 {
2301 LOG_ERROR("couldn't initialize FT2232 with 'JTAGkey' layout");
2302 return ERROR_JTAG_INIT_FAILED;
2303 }
2304
2305 nTRST = 0x01;
2306 nTRSTnOE = 0x4;
2307 nSRST = 0x02;
2308 nSRSTnOE = 0x00; /* no output enable for nSRST */
2309
2310 high_output = 0x0;
2311 high_direction = 0x0f;
2312
2313 if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
2314 {
2315 high_output |= nTRSTnOE;
2316 high_output &= ~nTRST;
2317 }
2318 else
2319 {
2320 high_output &= ~nTRSTnOE;
2321 high_output |= nTRST;
2322 }
2323
2324 if (jtag_reset_config & RESET_SRST_PUSH_PULL)
2325 {
2326 LOG_ERROR("can't set nSRST to push-pull on the Olimex ARM-USB-OCD");
2327 }
2328 else
2329 {
2330 high_output &= ~nSRST;
2331 }
2332
2333 /* turn red LED on */
2334 high_output |= 0x08;
2335
2336 /* initialize high port */
2337 buf[0] = 0x82; /* command "set data bits high byte" */
2338 buf[1] = high_output; /* value */
2339 buf[2] = high_direction; /* all outputs (xRST and xRSTnOE) */
2340 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2341
2342 if ( ( ( ft2232_write(buf, 3, &bytes_written) ) != ERROR_OK ) || (bytes_written != 3) )
2343 {
2344 LOG_ERROR("couldn't initialize FT2232 with 'JTAGkey' layout");
2345 return ERROR_JTAG_INIT_FAILED;
2346 }
2347
2348 return ERROR_OK;
2349 }
2350
2351
2352 static int flyswatter_init(void)
2353 {
2354 u8 buf[3];
2355 u32 bytes_written;
2356
2357 low_output = 0x18;
2358 low_direction = 0xfb;
2359
2360 /* initialize low byte for jtag */
2361 buf[0] = 0x80; /* command "set data bits low byte" */
2362 buf[1] = low_output; /* value (TMS=1,TCK=0, TDI=0, nOE=0) */
2363 buf[2] = low_direction; /* dir (output=1), TCK/TDI/TMS=out, TDO=in, nOE[12]=out, n[ST]srst=out */
2364 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2365
2366 if ( ( ( ft2232_write(buf, 3, &bytes_written) ) != ERROR_OK ) || (bytes_written != 3) )
2367 {
2368 LOG_ERROR("couldn't initialize FT2232 with 'flyswatter' layout");
2369 return ERROR_JTAG_INIT_FAILED;
2370 }
2371
2372 nTRST = 0x10;
2373 nTRSTnOE = 0x0; /* not output enable for nTRST */
2374 nSRST = 0x20;
2375 nSRSTnOE = 0x00; /* no output enable for nSRST */
2376
2377 high_output = 0x00;
2378 high_direction = 0x0c;
2379
2380 /* turn red LED3 on, LED2 off */
2381 high_output |= 0x08;
2382
2383 /* initialize high port */
2384 buf[0] = 0x82; /* command "set data bits high byte" */
2385 buf[1] = high_output; /* value */
2386 buf[2] = high_direction; /* all outputs (xRST and xRSTnOE) */
2387 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2388
2389 if ( ( ( ft2232_write(buf, 3, &bytes_written) ) != ERROR_OK ) || (bytes_written != 3) )
2390 {
2391 LOG_ERROR("couldn't initialize FT2232 with 'flyswatter' layout");
2392 return ERROR_JTAG_INIT_FAILED;
2393 }
2394
2395 return ERROR_OK;
2396 }
2397
2398
2399 static int turtle_init(void)
2400 {
2401 u8 buf[3];
2402 u32 bytes_written;
2403
2404 low_output = 0x08;
2405 low_direction = 0x5b;
2406
2407 /* initialize low byte for jtag */
2408 buf[0] = 0x80; /* command "set data bits low byte" */
2409 buf[1] = low_output; /* value (TMS=1,TCK=0, TDI=0, nOE=0) */
2410 buf[2] = low_direction; /* dir (output=1), TCK/TDI/TMS=out, TDO=in, nOE=out */
2411 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2412
2413 if ( ( ( ft2232_write(buf, 3, &bytes_written) ) != ERROR_OK ) || (bytes_written != 3) )
2414 {
2415 LOG_ERROR("couldn't initialize FT2232 with 'turtelizer2' layout");
2416 return ERROR_JTAG_INIT_FAILED;
2417 }
2418
2419 nSRST = 0x40;
2420
2421 high_output = 0x00;
2422 high_direction = 0x0C;
2423
2424 /* initialize high port */
2425 buf[0] = 0x82; /* command "set data bits high byte" */
2426 buf[1] = high_output;
2427 buf[2] = high_direction;
2428 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2429
2430 if ( ( ( ft2232_write(buf, 3, &bytes_written) ) != ERROR_OK ) || (bytes_written != 3) )
2431 {
2432 LOG_ERROR("couldn't initialize FT2232 with 'turtelizer2' layout");
2433 return ERROR_JTAG_INIT_FAILED;
2434 }
2435
2436 return ERROR_OK;
2437 }
2438
2439
2440 static int comstick_init(void)
2441 {
2442 u8 buf[3];
2443 u32 bytes_written;
2444
2445 low_output = 0x08;
2446 low_direction = 0x0b;
2447
2448 /* initialize low byte for jtag */
2449 buf[0] = 0x80; /* command "set data bits low byte" */
2450 buf[1] = low_output; /* value (TMS=1,TCK=0, TDI=0, nOE=0) */
2451 buf[2] = low_direction; /* dir (output=1), TCK/TDI/TMS=out, TDO=in, nOE=out */
2452 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2453
2454 if ( ( ( ft2232_write(buf, 3, &bytes_written) ) != ERROR_OK ) || (bytes_written != 3) )
2455 {
2456 LOG_ERROR("couldn't initialize FT2232 with 'comstick' layout");
2457 return ERROR_JTAG_INIT_FAILED;
2458 }
2459
2460 nTRST = 0x01;
2461 nTRSTnOE = 0x00; /* no output enable for nTRST */
2462 nSRST = 0x02;
2463 nSRSTnOE = 0x00; /* no output enable for nSRST */
2464
2465 high_output = 0x03;
2466 high_direction = 0x03;
2467
2468 /* initialize high port */
2469 buf[0] = 0x82; /* command "set data bits high byte" */
2470 buf[1] = high_output;
2471 buf[2] = high_direction;
2472 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2473
2474 if ( ( ( ft2232_write(buf, 3, &bytes_written) ) != ERROR_OK ) || (bytes_written != 3) )
2475 {
2476 LOG_ERROR("couldn't initialize FT2232 with 'comstick' layout");
2477 return ERROR_JTAG_INIT_FAILED;
2478 }
2479
2480 return ERROR_OK;
2481 }
2482
2483
2484 static int stm32stick_init(void)
2485 {
2486 u8 buf[3];
2487 u32 bytes_written;
2488
2489 low_output = 0x88;
2490 low_direction = 0x8b;
2491
2492 /* initialize low byte for jtag */
2493 buf[0] = 0x80; /* command "set data bits low byte" */
2494 buf[1] = low_output; /* value (TMS=1,TCK=0, TDI=0, nOE=0) */
2495 buf[2] = low_direction; /* dir (output=1), TCK/TDI/TMS=out, TDO=in, nOE=out */
2496 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2497
2498 if ( ( ( ft2232_write(buf, 3, &bytes_written) ) != ERROR_OK ) || (bytes_written != 3) )
2499 {
2500 LOG_ERROR("couldn't initialize FT2232 with 'stm32stick' layout");
2501 return ERROR_JTAG_INIT_FAILED;
2502 }
2503
2504 nTRST = 0x01;
2505 nTRSTnOE = 0x00; /* no output enable for nTRST */
2506 nSRST = 0x80;
2507 nSRSTnOE = 0x00; /* no output enable for nSRST */
2508
2509 high_output = 0x01;
2510 high_direction = 0x03;
2511
2512 /* initialize high port */
2513 buf[0] = 0x82; /* command "set data bits high byte" */
2514 buf[1] = high_output;
2515 buf[2] = high_direction;
2516 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2517
2518 if ( ( ( ft2232_write(buf, 3, &bytes_written) ) != ERROR_OK ) || (bytes_written != 3) )
2519 {
2520 LOG_ERROR("couldn't initialize FT2232 with 'stm32stick' layout");
2521 return ERROR_JTAG_INIT_FAILED;
2522 }
2523
2524 return ERROR_OK;
2525 }
2526
2527
2528 static int sheevaplug_init(void)
2529 {
2530 u8 buf[3];
2531 u32 bytes_written;
2532
2533 low_output = 0x08;
2534 low_direction = 0x1b;
2535
2536 /* initialize low byte for jtag */
2537 buf[0] = 0x80; /* command "set data bits low byte" */
2538 buf[1] = low_output; /* value (TMS=1,TCK=0, TDI=0, nOE=0) */
2539 buf[2] = low_direction; /* dir (output=1), TCK/TDI/TMS=out, TDO=in */
2540 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2541
2542 if (((ft2232_write(buf, 3, &bytes_written)) != ERROR_OK) || (bytes_written != 3))
2543 {
2544 LOG_ERROR("couldn't initialize FT2232 with 'sheevaplug' layout");
2545 return ERROR_JTAG_INIT_FAILED;
2546 }
2547
2548 nTRSTnOE = 0x1;
2549 nTRST = 0x02;
2550 nSRSTnOE = 0x4;
2551 nSRST = 0x08;
2552
2553 high_output = 0x0;
2554 high_direction = 0x0f;
2555
2556 /* nTRST is always push-pull */
2557 high_output &= ~nTRSTnOE;
2558 high_output |= nTRST;
2559
2560 /* nSRST is always open-drain */
2561 high_output |= nSRSTnOE;
2562 high_output &= ~nSRST;
2563
2564 /* initialize high port */
2565 buf[0] = 0x82; /* command "set data bits high byte" */
2566 buf[1] = high_output; /* value */
2567 buf[2] = high_direction; /* all outputs - xRST */
2568 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2569
2570 if (((ft2232_write(buf, 3, &bytes_written)) != ERROR_OK) || (bytes_written != 3))
2571 {
2572 LOG_ERROR("couldn't initialize FT2232 with 'sheevaplug' layout");
2573 return ERROR_JTAG_INIT_FAILED;
2574 }
2575
2576 return ERROR_OK;
2577 }
2578
2579 static void olimex_jtag_blink(void)
2580 {
2581 /* Olimex ARM-USB-OCD has a LED connected to ACBUS3
2582 * ACBUS3 is bit 3 of the GPIOH port
2583 */
2584 if (high_output & 0x08)
2585 {
2586 /* set port pin high */
2587 high_output &= 0x07;
2588 }
2589 else
2590 {
2591 /* set port pin low */
2592 high_output |= 0x08;
2593 }
2594
2595 buffer_write( 0x82 );
2596 buffer_write( high_output );
2597 buffer_write( high_direction );
2598 }
2599
2600
2601 static void flyswatter_jtag_blink(void)
2602 {
2603 /*
2604 * Flyswatter has two LEDs connected to ACBUS2 and ACBUS3
2605 */
2606 high_output ^= 0x0c;
2607
2608 buffer_write( 0x82 );
2609 buffer_write( high_output );
2610 buffer_write( high_direction );
2611 }
2612
2613
2614 static void turtle_jtag_blink(void)
2615 {
2616 /*
2617 * Turtelizer2 has two LEDs connected to ACBUS2 and ACBUS3
2618 */
2619 if (high_output & 0x08)
2620 {
2621 high_output = 0x04;
2622 }
2623 else
2624 {
2625 high_output = 0x08;
2626 }
2627
2628 buffer_write( 0x82 );
2629 buffer_write( high_output );
2630 buffer_write( high_direction );
2631 }
2632
2633
2634 static int ft2232_quit(void)
2635 {
2636 #if BUILD_FT2232_FTD2XX == 1
2637 FT_STATUS status;
2638
2639 status = FT_Close(ftdih);
2640 #elif BUILD_FT2232_LIBFTDI == 1
2641 ftdi_usb_close(&ftdic);
2642
2643 ftdi_deinit(&ftdic);
2644 #endif
2645
2646 free(ft2232_buffer);
2647 ft2232_buffer = NULL;
2648
2649 return ERROR_OK;
2650 }
2651
2652
2653 static int ft2232_handle_device_desc_command(struct command_context_s* cmd_ctx, char* cmd, char** args, int argc)
2654 {
2655 char *cp;
2656 char buf[200];
2657 if (argc == 1)
2658 {
2659 ft2232_device_desc = strdup(args[0]);
2660 cp = strchr( ft2232_device_desc, 0 );
2661 // under Win32, the FTD2XX driver appends an "A" to the end
2662 // of the description, this examines the given desc
2663 // and creates the 'missing' _A or non_A variable.
2664 if( (cp[-1] == 'A') && (cp[-2]==' ') ){
2665 // it was, so make this the "A" version.
2666 ft2232_device_desc_A = ft2232_device_desc;
2667 // and *CREATE* the non-A version.
2668 strcpy( buf, ft2232_device_desc );
2669 cp = strchr( buf, 0 );
2670 cp[-2] = 0;
2671 ft2232_device_desc = strdup( buf );
2672 } else {
2673 // <space>A not defined
2674 // so create it
2675 sprintf( buf, "%s A", ft2232_device_desc );
2676 ft2232_device_desc_A = strdup( buf );
2677 }
2678 }
2679 else
2680 {
2681 LOG_ERROR("expected exactly one argument to ft2232_device_desc <description>");
2682 }
2683
2684 return ERROR_OK;
2685 }
2686
2687
2688 static int ft2232_handle_serial_command(struct command_context_s* cmd_ctx, char* cmd, char** args, int argc)
2689 {
2690 if (argc == 1)
2691 {
2692 ft2232_serial = strdup(args[0]);
2693 }
2694 else
2695 {
2696 LOG_ERROR("expected exactly one argument to ft2232_serial <serial-number>");
2697 }
2698
2699 return ERROR_OK;
2700 }
2701
2702
2703 static int ft2232_handle_layout_command(struct command_context_s* cmd_ctx, char* cmd, char** args, int argc)
2704 {
2705 if (argc == 0)
2706 return ERROR_OK;
2707
2708 ft2232_layout = malloc(strlen(args[0]) + 1);
2709 strcpy(ft2232_layout, args[0]);
2710
2711 return ERROR_OK;
2712 }
2713
2714
2715 static int ft2232_handle_vid_pid_command(struct command_context_s* cmd_ctx, char* cmd, char** args, int argc)
2716 {
2717 int i;
2718
2719 if (argc > MAX_USB_IDS * 2)
2720 {
2721 LOG_WARNING("ignoring extra IDs in ft2232_vid_pid "
2722 "(maximum is %d pairs)", MAX_USB_IDS);
2723 argc = MAX_USB_IDS * 2;
2724 }
2725 if ( argc < 2 || (argc & 1) )
2726 {
2727 LOG_WARNING("incomplete ft2232_vid_pid configuration directive");
2728 if (argc < 2)
2729 return ERROR_OK;
2730 }
2731
2732 for (i = 0; i + 1 < argc; i += 2)
2733 {
2734 ft2232_vid[i >> 1] = strtol(args[i], NULL, 0);
2735 ft2232_pid[i >> 1] = strtol(args[i + 1], NULL, 0);
2736 }
2737
2738 /*
2739 * Explicitly terminate, in case there are multiples instances of
2740 * ft2232_vid_pid.
2741 */
2742 ft2232_vid[i >> 1] = ft2232_pid[i >> 1] = 0;
2743
2744 return ERROR_OK;
2745 }
2746
2747
2748 static int ft2232_handle_latency_command(struct command_context_s* cmd_ctx, char* cmd, char** args, int argc)
2749 {
2750 if (argc == 1)
2751 {
2752 ft2232_latency = atoi(args[0]);
2753 }
2754 else
2755 {
2756 LOG_ERROR("expected exactly one argument to ft2232_latency <ms>");
2757 }
2758
2759 return ERROR_OK;
2760 }
2761
2762
2763 static int ft2232_stableclocks(int num_cycles, jtag_command_t* cmd)
2764 {
2765 int retval = 0;
2766
2767 /* 7 bits of either ones or zeros. */
2768 u8 tms = (tap_get_state() == TAP_RESET ? 0x7F : 0x00);
2769
2770 while (num_cycles > 0)
2771 {
2772 /* the command 0x4b, "Clock Data to TMS/CS Pin (no Read)" handles
2773 * at most 7 bits per invocation. Here we invoke it potentially
2774 * several times.
2775 */
2776 int bitcount_per_command = (num_cycles > 7) ? 7 : num_cycles;
2777
2778 if (ft2232_buffer_size + 3 >= FT2232_BUFFER_SIZE)
2779 {
2780 if (ft2232_send_and_recv(first_unsent, cmd) != ERROR_OK)
2781 retval = ERROR_JTAG_QUEUE_FAILED;
2782
2783 first_unsent = cmd;
2784 }
2785
2786 /* there are no state transitions in this code, so omit state tracking */
2787
2788 /* command "Clock Data to TMS/CS Pin (no Read)" */
2789 buffer_write( 0x4b );
2790
2791 /* scan 7 bit */
2792 buffer_write( bitcount_per_command - 1 );
2793
2794 /* TMS data bits are either all zeros or ones to stay in the current stable state */
2795 buffer_write( tms );
2796
2797 require_send = 1;
2798
2799 num_cycles -= bitcount_per_command;
2800 }
2801
2802 return retval;
2803 }
2804
2805
2806 /* ---------------------------------------------------------------------
2807 * Support for IceBear JTAG adapter from Section5:
2808 * http://section5.ch/icebear
2809 *
2810 * Author: Sten, debian@sansys-electronic.com
2811 */
2812
2813 /* Icebear pin layout
2814 *
2815 * ADBUS5 (nEMU) nSRST | 2 1| GND (10k->VCC)
2816 * GND GND | 4 3| n.c.
2817 * ADBUS3 TMS | 6 5| ADBUS6 VCC
2818 * ADBUS0 TCK | 8 7| ADBUS7 (GND)
2819 * ADBUS4 nTRST |10 9| ACBUS0 (GND)
2820 * ADBUS1 TDI |12 11| ACBUS1 (GND)
2821 * ADBUS2 TDO |14 13| GND GND
2822 *
2823 * ADBUS0 O L TCK ACBUS0 GND
2824 * ADBUS1 O L TDI ACBUS1 GND
2825 * ADBUS2 I TDO ACBUS2 n.c.
2826 * ADBUS3 O H TMS ACBUS3 n.c.
2827 * ADBUS4 O H nTRST
2828 * ADBUS5 O H nSRST
2829 * ADBUS6 - VCC
2830 * ADBUS7 - GND
2831 */
2832 static int icebear_jtag_init(void) {
2833 u8 buf[3];
2834 u32 bytes_written;
2835
2836 low_direction = 0x0b; /* output: TCK TDI TMS; input: TDO */
2837 low_output = 0x08; /* high: TMS; low: TCK TDI */
2838 nTRST = 0x10;
2839 nSRST = 0x20;
2840
2841 if ((jtag_reset_config & RESET_TRST_OPEN_DRAIN) != 0) {
2842 low_direction &= ~nTRST; /* nTRST high impedance */
2843 }
2844 else {
2845 low_direction |= nTRST;
2846 low_output |= nTRST;
2847 }
2848
2849 low_direction |= nSRST;
2850 low_output |= nSRST;
2851
2852 /* initialize low byte for jtag */
2853 buf[0] = 0x80; /* command "set data bits low byte" */
2854 buf[1] = low_output;
2855 buf[2] = low_direction;
2856 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2857
2858 if ( ( ( ft2232_write(buf, 3, &bytes_written) ) != ERROR_OK ) || (bytes_written != 3) ) {
2859 LOG_ERROR("couldn't initialize FT2232 with 'IceBear' layout (low)");
2860 return ERROR_JTAG_INIT_FAILED;
2861 }
2862
2863 high_output = 0x0;
2864 high_direction = 0x00;
2865
2866
2867 /* initialize high port */
2868 buf[0] = 0x82; /* command "set data bits high byte" */
2869 buf[1] = high_output; /* value */
2870 buf[2] = high_direction; /* all outputs (xRST and xRSTnOE) */
2871 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2872
2873 if ( ( ( ft2232_write(buf, 3, &bytes_written) ) != ERROR_OK ) || (bytes_written != 3) ) {
2874 LOG_ERROR("couldn't initialize FT2232 with 'IceBear' layout (high)");
2875 return ERROR_JTAG_INIT_FAILED;
2876 }
2877
2878 return ERROR_OK;
2879 }
2880
2881 static void icebear_jtag_reset(int trst, int srst) {
2882
2883 if (trst == 1) {
2884 low_direction |= nTRST;
2885 low_output &= ~nTRST;
2886 }
2887 else if (trst == 0) {
2888 if ((jtag_reset_config & RESET_TRST_OPEN_DRAIN) != 0)
2889 low_direction &= ~nTRST;
2890 else
2891 low_output |= nTRST;
2892 }
2893
2894 if (srst == 1) {
2895 low_output &= ~nSRST;
2896 }
2897 else if (srst == 0) {
2898 low_output |= nSRST;
2899 }
2900
2901 /* command "set data bits low byte" */
2902 buffer_write( 0x80 );
2903 buffer_write( low_output );
2904 buffer_write( low_direction );
2905
2906 LOG_DEBUG("trst: %i, srst: %i, low_output: 0x%2.2x, low_direction: 0x%2.2x", trst, srst, low_output, low_direction);
2907 }
Open On-Chip Debugger

Linking to existing account procedure

If you already have an account and want to add another login method you MUST first sign in with your existing account and then change URL to read https://review.openocd.org/login/?link to get to this page again but this time it'll work for linking. Thank you.

SSH host keys fingerprints

1024 SHA256:YKx8b7u5ZWdcbp7/4AeXNaqElP49m6QrwfXaqQGJAOk gerrit-code-review@openocd.zylin.com (DSA)
384 SHA256:jHIbSQa4REvwCFG4cq5LBlBLxmxSqelQPem/EXIrxjk gerrit-code-review@openocd.org (ECDSA)
521 SHA256:UAOPYkU9Fjtcao0Ul/Rrlnj/OsQvt+pgdYSZ4jOYdgs gerrit-code-review@openocd.org (ECDSA)
256 SHA256:A13M5QlnozFOvTllybRZH6vm7iSt0XLxbA48yfc2yfY gerrit-code-review@openocd.org (ECDSA)
256 SHA256:spYMBqEYoAOtK7yZBrcwE8ZpYt6b68Cfh9yEVetvbXg gerrit-code-review@openocd.org (ED25519)
+--[ED25519 256]--+
|=..              |
|+o..   .         |
|*.o   . .        |
|+B . . .         |
|Bo. = o S        |
|Oo.+ + =         |
|oB=.* = . o      |
| =+=.+   + E     |
|. .=o   . o      |
+----[SHA256]-----+
2048 SHA256:0Onrb7/PHjpo6iVZ7xQX2riKN83FJ3KGU0TvI0TaFG4 gerrit-code-review@openocd.zylin.com (RSA)