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