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