Code Review / openocd.git / blob
? search:
summary | shortlog | log | commit | commitdiff | review | tree
history | raw | HEAD
Break ft2232_execute_quie into smaller functions, follows restructure of jlink.c
[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 cmd = cmd->next;
1593 }
1594
1595 if (require_send > 0)
1596 if (ft2232_send_and_recv(first_unsent, cmd) != ERROR_OK)
1597 retval = ERROR_JTAG_QUEUE_FAILED;
1598
1599 return retval;
1600 }
1601
1602
1603 #if BUILD_FT2232_FTD2XX == 1
1604 static int ft2232_init_ftd2xx(u16 vid, u16 pid, int more, int* try_more)
1605 {
1606 FT_STATUS status;
1607 DWORD openex_flags = 0;
1608 char* openex_string = NULL;
1609 u8 latency_timer;
1610
1611 LOG_DEBUG("'ft2232' interface using FTD2XX with '%s' layout (%4.4x:%4.4x)", ft2232_layout, vid, pid);
1612
1613 #if IS_WIN32 == 0
1614 /* Add non-standard Vid/Pid to the linux driver */
1615 if ( ( status = FT_SetVIDPID(vid, pid) ) != FT_OK )
1616 {
1617 LOG_WARNING("couldn't add %4.4x:%4.4x", vid, pid);
1618 }
1619 #endif
1620
1621 if (ft2232_device_desc && ft2232_serial)
1622 {
1623 LOG_WARNING("can't open by device description and serial number, giving precedence to serial");
1624 ft2232_device_desc = NULL;
1625 }
1626
1627 if (ft2232_device_desc)
1628 {
1629 openex_string = ft2232_device_desc;
1630 openex_flags = FT_OPEN_BY_DESCRIPTION;
1631 }
1632 else if (ft2232_serial)
1633 {
1634 openex_string = ft2232_serial;
1635 openex_flags = FT_OPEN_BY_SERIAL_NUMBER;
1636 }
1637 else
1638 {
1639 LOG_ERROR("neither device description nor serial number specified");
1640 LOG_ERROR("please add \"ft2232_device_desc <string>\" or \"ft2232_serial <string>\" to your .cfg file");
1641
1642 return ERROR_JTAG_INIT_FAILED;
1643 }
1644
1645 status = FT_OpenEx(openex_string, openex_flags, &ftdih);
1646 if( status != FT_OK ){
1647 // under Win32, the FTD2XX driver appends an "A" to the end
1648 // of the description, if we tried by the desc, then
1649 // try by the alternate "A" description.
1650 if( openex_string == ft2232_device_desc ){
1651 // Try the alternate method.
1652 openex_string = ft2232_device_desc_A;
1653 status = FT_OpenEx(openex_string, openex_flags, &ftdih);
1654 if( status == FT_OK ){
1655 // yea, the "alternate" method worked!
1656 } else {
1657 // drat, give the user a meaningfull message.
1658 // telling the use we tried *BOTH* methods.
1659 LOG_WARNING("Unable to open FTDI Device tried: '%s' and '%s'\n",
1660 ft2232_device_desc,
1661 ft2232_device_desc_A );
1662 }
1663 }
1664 }
1665
1666 if ( status != FT_OK )
1667 {
1668 DWORD num_devices;
1669
1670 if (more)
1671 {
1672 LOG_WARNING("unable to open ftdi device (trying more): %lu", status);
1673 *try_more = 1;
1674 return ERROR_JTAG_INIT_FAILED;
1675 }
1676 LOG_ERROR("unable to open ftdi device: %lu", status);
1677 status = FT_ListDevices(&num_devices, NULL, FT_LIST_NUMBER_ONLY);
1678 if (status == FT_OK)
1679 {
1680 char** desc_array = malloc( sizeof(char*) * (num_devices + 1) );
1681 u32 i;
1682
1683 for (i = 0; i < num_devices; i++)
1684 desc_array[i] = malloc(64);
1685
1686 desc_array[num_devices] = NULL;
1687
1688 status = FT_ListDevices(desc_array, &num_devices, FT_LIST_ALL | openex_flags);
1689
1690 if (status == FT_OK)
1691 {
1692 LOG_ERROR("ListDevices: %lu\n", num_devices);
1693 for (i = 0; i < num_devices; i++)
1694 LOG_ERROR("%i: \"%s\"", i, desc_array[i]);
1695 }
1696
1697 for (i = 0; i < num_devices; i++)
1698 free(desc_array[i]);
1699
1700 free(desc_array);
1701 }
1702 else
1703 {
1704 LOG_ERROR("ListDevices: NONE\n");
1705 }
1706 return ERROR_JTAG_INIT_FAILED;
1707 }
1708
1709 if ( ( status = FT_SetLatencyTimer(ftdih, ft2232_latency) ) != FT_OK )
1710 {
1711 LOG_ERROR("unable to set latency timer: %lu", status);
1712 return ERROR_JTAG_INIT_FAILED;
1713 }
1714
1715 if ( ( status = FT_GetLatencyTimer(ftdih, &latency_timer) ) != FT_OK )
1716 {
1717 LOG_ERROR("unable to get latency timer: %lu", status);
1718 return ERROR_JTAG_INIT_FAILED;
1719 }
1720 else
1721 {
1722 LOG_DEBUG("current latency timer: %i", latency_timer);
1723 }
1724
1725 if ( ( status = FT_SetTimeouts(ftdih, 5000, 5000) ) != FT_OK )
1726 {
1727 LOG_ERROR("unable to set timeouts: %lu", status);
1728 return ERROR_JTAG_INIT_FAILED;
1729 }
1730
1731 if ( ( status = FT_SetBitMode(ftdih, 0x0b, 2) ) != FT_OK )
1732 {
1733 LOG_ERROR("unable to enable bit i/o mode: %lu", status);
1734 return ERROR_JTAG_INIT_FAILED;
1735 }
1736
1737 return ERROR_OK;
1738 }
1739
1740
1741 static int ft2232_purge_ftd2xx(void)
1742 {
1743 FT_STATUS status;
1744
1745 if ( ( status = FT_Purge(ftdih, FT_PURGE_RX | FT_PURGE_TX) ) != FT_OK )
1746 {
1747 LOG_ERROR("error purging ftd2xx device: %lu", status);
1748 return ERROR_JTAG_INIT_FAILED;
1749 }
1750
1751 return ERROR_OK;
1752 }
1753
1754
1755 #endif /* BUILD_FT2232_FTD2XX == 1 */
1756
1757 #if BUILD_FT2232_LIBFTDI == 1
1758 static int ft2232_init_libftdi(u16 vid, u16 pid, int more, int* try_more)
1759 {
1760 u8 latency_timer;
1761
1762 LOG_DEBUG("'ft2232' interface using libftdi with '%s' layout (%4.4x:%4.4x)",
1763 ft2232_layout, vid, pid);
1764
1765 if (ftdi_init(&ftdic) < 0)
1766 return ERROR_JTAG_INIT_FAILED;
1767
1768 /* context, vendor id, product id */
1769 if (ftdi_usb_open_desc(&ftdic, vid, pid, ft2232_device_desc,
1770 ft2232_serial) < 0)
1771 {
1772 if (more)
1773 LOG_WARNING("unable to open ftdi device (trying more): %s",
1774 ftdic.error_str);
1775 else
1776 LOG_ERROR("unable to open ftdi device: %s", ftdic.error_str);
1777 *try_more = 1;
1778 return ERROR_JTAG_INIT_FAILED;
1779 }
1780
1781 if (ftdi_set_interface(&ftdic, INTERFACE_A) < 0)
1782 {
1783 LOG_ERROR("unable to select FT2232 channel A: %s", ftdic.error_str);
1784 return ERROR_JTAG_INIT_FAILED;
1785 }
1786
1787 if (ftdi_usb_reset(&ftdic) < 0)
1788 {
1789 LOG_ERROR("unable to reset ftdi device");
1790 return ERROR_JTAG_INIT_FAILED;
1791 }
1792
1793 if (ftdi_set_latency_timer(&ftdic, ft2232_latency) < 0)
1794 {
1795 LOG_ERROR("unable to set latency timer");
1796 return ERROR_JTAG_INIT_FAILED;
1797 }
1798
1799 if (ftdi_get_latency_timer(&ftdic, &latency_timer) < 0)
1800 {
1801 LOG_ERROR("unable to get latency timer");
1802 return ERROR_JTAG_INIT_FAILED;
1803 }
1804 else
1805 {
1806 LOG_DEBUG("current latency timer: %i", latency_timer);
1807 }
1808
1809 ftdi_set_bitmode(&ftdic, 0x0b, 2); /* ctx, JTAG I/O mask */
1810
1811 return ERROR_OK;
1812 }
1813
1814
1815 static int ft2232_purge_libftdi(void)
1816 {
1817 if (ftdi_usb_purge_buffers(&ftdic) < 0)
1818 {
1819 LOG_ERROR("ftdi_purge_buffers: %s", ftdic.error_str);
1820 return ERROR_JTAG_INIT_FAILED;
1821 }
1822
1823 return ERROR_OK;
1824 }
1825
1826
1827 #endif /* BUILD_FT2232_LIBFTDI == 1 */
1828
1829 static int ft2232_init(void)
1830 {
1831 u8 buf[1];
1832 int retval;
1833 u32 bytes_written;
1834 ft2232_layout_t* cur_layout = ft2232_layouts;
1835 int i;
1836
1837 if ( (ft2232_layout == NULL) || (ft2232_layout[0] == 0) )
1838 {
1839 ft2232_layout = "usbjtag";
1840 LOG_WARNING("No ft2232 layout specified, using default 'usbjtag'");
1841 }
1842
1843 while (cur_layout->name)
1844 {
1845 if (strcmp(cur_layout->name, ft2232_layout) == 0)
1846 {
1847 layout = cur_layout;
1848 break;
1849 }
1850 cur_layout++;
1851 }
1852
1853 if (!layout)
1854 {
1855 LOG_ERROR("No matching layout found for %s", ft2232_layout);
1856 return ERROR_JTAG_INIT_FAILED;
1857 }
1858
1859 for (i = 0; 1; i++)
1860 {
1861 /*
1862 * "more indicates that there are more IDs to try, so we should
1863 * not print an error for an ID mismatch (but for anything
1864 * else, we should).
1865 *
1866 * try_more indicates that the error code returned indicates an
1867 * ID mismatch (and nothing else) and that we should proceeed
1868 * with the next ID pair.
1869 */
1870 int more = ft2232_vid[i + 1] || ft2232_pid[i + 1];
1871 int try_more = 0;
1872
1873 #if BUILD_FT2232_FTD2XX == 1
1874 retval = ft2232_init_ftd2xx(ft2232_vid[i], ft2232_pid[i],
1875 more, &try_more);
1876 #elif BUILD_FT2232_LIBFTDI == 1
1877 retval = ft2232_init_libftdi(ft2232_vid[i], ft2232_pid[i],
1878 more, &try_more);
1879 #endif
1880 if (retval >= 0)
1881 break;
1882 if (!more || !try_more)
1883 return retval;
1884 }
1885
1886 ft2232_buffer_size = 0;
1887 ft2232_buffer = malloc(FT2232_BUFFER_SIZE);
1888
1889 if (layout->init() != ERROR_OK)
1890 return ERROR_JTAG_INIT_FAILED;
1891
1892 ft2232_speed(jtag_speed);
1893
1894 buf[0] = 0x85; /* Disconnect TDI/DO to TDO/DI for Loopback */
1895 if ( ( ( retval = ft2232_write(buf, 1, &bytes_written) ) != ERROR_OK ) || (bytes_written != 1) )
1896 {
1897 LOG_ERROR("couldn't write to FT2232 to disable loopback");
1898 return ERROR_JTAG_INIT_FAILED;
1899 }
1900
1901 #if BUILD_FT2232_FTD2XX == 1
1902 return ft2232_purge_ftd2xx();
1903 #elif BUILD_FT2232_LIBFTDI == 1
1904 return ft2232_purge_libftdi();
1905 #endif
1906
1907 return ERROR_OK;
1908 }
1909
1910
1911 static int usbjtag_init(void)
1912 {
1913 u8 buf[3];
1914 u32 bytes_written;
1915
1916 low_output = 0x08;
1917 low_direction = 0x0b;
1918
1919 if (strcmp(ft2232_layout, "usbjtag") == 0)
1920 {
1921 nTRST = 0x10;
1922 nTRSTnOE = 0x10;
1923 nSRST = 0x40;
1924 nSRSTnOE = 0x40;
1925 }
1926 else if (strcmp(ft2232_layout, "signalyzer") == 0)
1927 {
1928 nTRST = 0x10;
1929 nTRSTnOE = 0x10;
1930 nSRST = 0x20;
1931 nSRSTnOE = 0x20;
1932 }
1933 else if (strcmp(ft2232_layout, "evb_lm3s811") == 0)
1934 {
1935 nTRST = 0x0;
1936 nTRSTnOE = 0x00;
1937 nSRST = 0x20;
1938 nSRSTnOE = 0x20;
1939 low_output = 0x88;
1940 low_direction = 0x8b;
1941 }
1942 else
1943 {
1944 LOG_ERROR("BUG: usbjtag_init called for unknown layout '%s'", ft2232_layout);
1945 return ERROR_JTAG_INIT_FAILED;
1946 }
1947
1948 if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
1949 {
1950 low_direction &= ~nTRSTnOE; /* nTRST input */
1951 low_output &= ~nTRST; /* nTRST = 0 */
1952 }
1953 else
1954 {
1955 low_direction |= nTRSTnOE; /* nTRST output */
1956 low_output |= nTRST; /* nTRST = 1 */
1957 }
1958
1959 if (jtag_reset_config & RESET_SRST_PUSH_PULL)
1960 {
1961 low_direction |= nSRSTnOE; /* nSRST output */
1962 low_output |= nSRST; /* nSRST = 1 */
1963 }
1964 else
1965 {
1966 low_direction &= ~nSRSTnOE; /* nSRST input */
1967 low_output &= ~nSRST; /* nSRST = 0 */
1968 }
1969
1970 /* initialize low byte for jtag */
1971 buf[0] = 0x80; /* command "set data bits low byte" */
1972 buf[1] = low_output; /* value (TMS=1,TCK=0, TDI=0, xRST high) */
1973 buf[2] = low_direction; /* dir (output=1), TCK/TDI/TMS=out, TDO=in */
1974 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
1975
1976 if ( ( ( ft2232_write(buf, 3, &bytes_written) ) != ERROR_OK ) || (bytes_written != 3) )
1977 {
1978 LOG_ERROR("couldn't initialize FT2232 with 'USBJTAG' layout");
1979 return ERROR_JTAG_INIT_FAILED;
1980 }
1981
1982 return ERROR_OK;
1983 }
1984
1985
1986 static int axm0432_jtag_init(void)
1987 {
1988 u8 buf[3];
1989 u32 bytes_written;
1990
1991 low_output = 0x08;
1992 low_direction = 0x2b;
1993
1994 /* initialize low byte for jtag */
1995 buf[0] = 0x80; /* command "set data bits low byte" */
1996 buf[1] = low_output; /* value (TMS=1,TCK=0, TDI=0, nOE=0) */
1997 buf[2] = low_direction; /* dir (output=1), TCK/TDI/TMS=out, TDO=in, nOE=out */
1998 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
1999
2000 if ( ( ( ft2232_write(buf, 3, &bytes_written) ) != ERROR_OK ) || (bytes_written != 3) )
2001 {
2002 LOG_ERROR("couldn't initialize FT2232 with 'JTAGkey' layout");
2003 return ERROR_JTAG_INIT_FAILED;
2004 }
2005
2006 if (strcmp(layout->name, "axm0432_jtag") == 0)
2007 {
2008 nTRST = 0x08;
2009 nTRSTnOE = 0x0; /* No output enable for TRST*/
2010 nSRST = 0x04;
2011 nSRSTnOE = 0x0; /* No output enable for SRST*/
2012 }
2013 else
2014 {
2015 LOG_ERROR("BUG: axm0432_jtag_init called for non axm0432 layout");
2016 exit(-1);
2017 }
2018
2019 high_output = 0x0;
2020 high_direction = 0x0c;
2021
2022 if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
2023 {
2024 LOG_ERROR("can't set nTRSTOE to push-pull on the Dicarlo jtag");
2025 }
2026 else
2027 {
2028 high_output |= nTRST;
2029 }
2030
2031 if (jtag_reset_config & RESET_SRST_PUSH_PULL)
2032 {
2033 LOG_ERROR("can't set nSRST to push-pull on the Dicarlo jtag");
2034 }
2035 else
2036 {
2037 high_output |= nSRST;
2038 }
2039
2040 /* initialize high port */
2041 buf[0] = 0x82; /* command "set data bits high byte" */
2042 buf[1] = high_output; /* value */
2043 buf[2] = high_direction; /* all outputs (xRST and xRSTnOE) */
2044 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2045
2046 if ( ( ( ft2232_write(buf, 3, &bytes_written) ) != ERROR_OK ) || (bytes_written != 3) )
2047 {
2048 LOG_ERROR("couldn't initialize FT2232 with 'Dicarlo' layout");
2049 return ERROR_JTAG_INIT_FAILED;
2050 }
2051
2052 return ERROR_OK;
2053 }
2054
2055
2056 static int jtagkey_init(void)
2057 {
2058 u8 buf[3];
2059 u32 bytes_written;
2060
2061 low_output = 0x08;
2062 low_direction = 0x1b;
2063
2064 /* initialize low byte for jtag */
2065 buf[0] = 0x80; /* command "set data bits low byte" */
2066 buf[1] = low_output; /* value (TMS=1,TCK=0, TDI=0, nOE=0) */
2067 buf[2] = low_direction; /* dir (output=1), TCK/TDI/TMS=out, TDO=in, nOE=out */
2068 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2069
2070 if ( ( ( ft2232_write(buf, 3, &bytes_written) ) != ERROR_OK ) || (bytes_written != 3) )
2071 {
2072 LOG_ERROR("couldn't initialize FT2232 with 'JTAGkey' layout");
2073 return ERROR_JTAG_INIT_FAILED;
2074 }
2075
2076 if (strcmp(layout->name, "jtagkey") == 0)
2077 {
2078 nTRST = 0x01;
2079 nTRSTnOE = 0x4;
2080 nSRST = 0x02;
2081 nSRSTnOE = 0x08;
2082 }
2083 else if ( (strcmp(layout->name, "jtagkey_prototype_v1") == 0)
2084 || (strcmp(layout->name, "oocdlink") == 0) )
2085 {
2086 nTRST = 0x02;
2087 nTRSTnOE = 0x1;
2088 nSRST = 0x08;
2089 nSRSTnOE = 0x04;
2090 }
2091 else
2092 {
2093 LOG_ERROR("BUG: jtagkey_init called for non jtagkey layout");
2094 exit(-1);
2095 }
2096
2097 high_output = 0x0;
2098 high_direction = 0x0f;
2099
2100 if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
2101 {
2102 high_output |= nTRSTnOE;
2103 high_output &= ~nTRST;
2104 }
2105 else
2106 {
2107 high_output &= ~nTRSTnOE;
2108 high_output |= nTRST;
2109 }
2110
2111 if (jtag_reset_config & RESET_SRST_PUSH_PULL)
2112 {
2113 high_output &= ~nSRSTnOE;
2114 high_output |= nSRST;
2115 }
2116 else
2117 {
2118 high_output |= nSRSTnOE;
2119 high_output &= ~nSRST;
2120 }
2121
2122 /* initialize high port */
2123 buf[0] = 0x82; /* command "set data bits high byte" */
2124 buf[1] = high_output; /* value */
2125 buf[2] = high_direction; /* all outputs (xRST and xRSTnOE) */
2126 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2127
2128 if ( ( ( ft2232_write(buf, 3, &bytes_written) ) != ERROR_OK ) || (bytes_written != 3) )
2129 {
2130 LOG_ERROR("couldn't initialize FT2232 with 'JTAGkey' layout");
2131 return ERROR_JTAG_INIT_FAILED;
2132 }
2133
2134 return ERROR_OK;
2135 }
2136
2137
2138 static int olimex_jtag_init(void)
2139 {
2140 u8 buf[3];
2141 u32 bytes_written;
2142
2143 low_output = 0x08;
2144 low_direction = 0x1b;
2145
2146 /* initialize low byte for jtag */
2147 buf[0] = 0x80; /* command "set data bits low byte" */
2148 buf[1] = low_output; /* value (TMS=1,TCK=0, TDI=0, nOE=0) */
2149 buf[2] = low_direction; /* dir (output=1), TCK/TDI/TMS=out, TDO=in, nOE=out */
2150 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2151
2152 if ( ( ( ft2232_write(buf, 3, &bytes_written) ) != ERROR_OK ) || (bytes_written != 3) )
2153 {
2154 LOG_ERROR("couldn't initialize FT2232 with 'JTAGkey' layout");
2155 return ERROR_JTAG_INIT_FAILED;
2156 }
2157
2158 nTRST = 0x01;
2159 nTRSTnOE = 0x4;
2160 nSRST = 0x02;
2161 nSRSTnOE = 0x00; /* no output enable for nSRST */
2162
2163 high_output = 0x0;
2164 high_direction = 0x0f;
2165
2166 if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
2167 {
2168 high_output |= nTRSTnOE;
2169 high_output &= ~nTRST;
2170 }
2171 else
2172 {
2173 high_output &= ~nTRSTnOE;
2174 high_output |= nTRST;
2175 }
2176
2177 if (jtag_reset_config & RESET_SRST_PUSH_PULL)
2178 {
2179 LOG_ERROR("can't set nSRST to push-pull on the Olimex ARM-USB-OCD");
2180 }
2181 else
2182 {
2183 high_output &= ~nSRST;
2184 }
2185
2186 /* turn red LED on */
2187 high_output |= 0x08;
2188
2189 /* initialize high port */
2190 buf[0] = 0x82; /* command "set data bits high byte" */
2191 buf[1] = high_output; /* value */
2192 buf[2] = high_direction; /* all outputs (xRST and xRSTnOE) */
2193 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2194
2195 if ( ( ( ft2232_write(buf, 3, &bytes_written) ) != ERROR_OK ) || (bytes_written != 3) )
2196 {
2197 LOG_ERROR("couldn't initialize FT2232 with 'JTAGkey' layout");
2198 return ERROR_JTAG_INIT_FAILED;
2199 }
2200
2201 return ERROR_OK;
2202 }
2203
2204
2205 static int flyswatter_init(void)
2206 {
2207 u8 buf[3];
2208 u32 bytes_written;
2209
2210 low_output = 0x18;
2211 low_direction = 0xfb;
2212
2213 /* initialize low byte for jtag */
2214 buf[0] = 0x80; /* command "set data bits low byte" */
2215 buf[1] = low_output; /* value (TMS=1,TCK=0, TDI=0, nOE=0) */
2216 buf[2] = low_direction; /* dir (output=1), TCK/TDI/TMS=out, TDO=in, nOE[12]=out, n[ST]srst=out */
2217 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2218
2219 if ( ( ( ft2232_write(buf, 3, &bytes_written) ) != ERROR_OK ) || (bytes_written != 3) )
2220 {
2221 LOG_ERROR("couldn't initialize FT2232 with 'flyswatter' layout");
2222 return ERROR_JTAG_INIT_FAILED;
2223 }
2224
2225 nTRST = 0x10;
2226 nTRSTnOE = 0x0; /* not output enable for nTRST */
2227 nSRST = 0x20;
2228 nSRSTnOE = 0x00; /* no output enable for nSRST */
2229
2230 high_output = 0x00;
2231 high_direction = 0x0c;
2232
2233 /* turn red LED3 on, LED2 off */
2234 high_output |= 0x08;
2235
2236 /* initialize high port */
2237 buf[0] = 0x82; /* command "set data bits high byte" */
2238 buf[1] = high_output; /* value */
2239 buf[2] = high_direction; /* all outputs (xRST and xRSTnOE) */
2240 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2241
2242 if ( ( ( ft2232_write(buf, 3, &bytes_written) ) != ERROR_OK ) || (bytes_written != 3) )
2243 {
2244 LOG_ERROR("couldn't initialize FT2232 with 'flyswatter' layout");
2245 return ERROR_JTAG_INIT_FAILED;
2246 }
2247
2248 return ERROR_OK;
2249 }
2250
2251
2252 static int turtle_init(void)
2253 {
2254 u8 buf[3];
2255 u32 bytes_written;
2256
2257 low_output = 0x08;
2258 low_direction = 0x5b;
2259
2260 /* initialize low byte for jtag */
2261 buf[0] = 0x80; /* command "set data bits low byte" */
2262 buf[1] = low_output; /* value (TMS=1,TCK=0, TDI=0, nOE=0) */
2263 buf[2] = low_direction; /* dir (output=1), TCK/TDI/TMS=out, TDO=in, nOE=out */
2264 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2265
2266 if ( ( ( ft2232_write(buf, 3, &bytes_written) ) != ERROR_OK ) || (bytes_written != 3) )
2267 {
2268 LOG_ERROR("couldn't initialize FT2232 with 'turtelizer2' layout");
2269 return ERROR_JTAG_INIT_FAILED;
2270 }
2271
2272 nSRST = 0x40;
2273
2274 high_output = 0x00;
2275 high_direction = 0x0C;
2276
2277 /* initialize high port */
2278 buf[0] = 0x82; /* command "set data bits high byte" */
2279 buf[1] = high_output;
2280 buf[2] = high_direction;
2281 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2282
2283 if ( ( ( ft2232_write(buf, 3, &bytes_written) ) != ERROR_OK ) || (bytes_written != 3) )
2284 {
2285 LOG_ERROR("couldn't initialize FT2232 with 'turtelizer2' layout");
2286 return ERROR_JTAG_INIT_FAILED;
2287 }
2288
2289 return ERROR_OK;
2290 }
2291
2292
2293 static int comstick_init(void)
2294 {
2295 u8 buf[3];
2296 u32 bytes_written;
2297
2298 low_output = 0x08;
2299 low_direction = 0x0b;
2300
2301 /* initialize low byte for jtag */
2302 buf[0] = 0x80; /* command "set data bits low byte" */
2303 buf[1] = low_output; /* value (TMS=1,TCK=0, TDI=0, nOE=0) */
2304 buf[2] = low_direction; /* dir (output=1), TCK/TDI/TMS=out, TDO=in, nOE=out */
2305 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2306
2307 if ( ( ( ft2232_write(buf, 3, &bytes_written) ) != ERROR_OK ) || (bytes_written != 3) )
2308 {
2309 LOG_ERROR("couldn't initialize FT2232 with 'comstick' layout");
2310 return ERROR_JTAG_INIT_FAILED;
2311 }
2312
2313 nTRST = 0x01;
2314 nTRSTnOE = 0x00; /* no output enable for nTRST */
2315 nSRST = 0x02;
2316 nSRSTnOE = 0x00; /* no output enable for nSRST */
2317
2318 high_output = 0x03;
2319 high_direction = 0x03;
2320
2321 /* initialize high port */
2322 buf[0] = 0x82; /* command "set data bits high byte" */
2323 buf[1] = high_output;
2324 buf[2] = high_direction;
2325 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2326
2327 if ( ( ( ft2232_write(buf, 3, &bytes_written) ) != ERROR_OK ) || (bytes_written != 3) )
2328 {
2329 LOG_ERROR("couldn't initialize FT2232 with 'comstick' layout");
2330 return ERROR_JTAG_INIT_FAILED;
2331 }
2332
2333 return ERROR_OK;
2334 }
2335
2336
2337 static int stm32stick_init(void)
2338 {
2339 u8 buf[3];
2340 u32 bytes_written;
2341
2342 low_output = 0x88;
2343 low_direction = 0x8b;
2344
2345 /* initialize low byte for jtag */
2346 buf[0] = 0x80; /* command "set data bits low byte" */
2347 buf[1] = low_output; /* value (TMS=1,TCK=0, TDI=0, nOE=0) */
2348 buf[2] = low_direction; /* dir (output=1), TCK/TDI/TMS=out, TDO=in, nOE=out */
2349 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2350
2351 if ( ( ( ft2232_write(buf, 3, &bytes_written) ) != ERROR_OK ) || (bytes_written != 3) )
2352 {
2353 LOG_ERROR("couldn't initialize FT2232 with 'stm32stick' layout");
2354 return ERROR_JTAG_INIT_FAILED;
2355 }
2356
2357 nTRST = 0x01;
2358 nTRSTnOE = 0x00; /* no output enable for nTRST */
2359 nSRST = 0x80;
2360 nSRSTnOE = 0x00; /* no output enable for nSRST */
2361
2362 high_output = 0x01;
2363 high_direction = 0x03;
2364
2365 /* initialize high port */
2366 buf[0] = 0x82; /* command "set data bits high byte" */
2367 buf[1] = high_output;
2368 buf[2] = high_direction;
2369 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2370
2371 if ( ( ( ft2232_write(buf, 3, &bytes_written) ) != ERROR_OK ) || (bytes_written != 3) )
2372 {
2373 LOG_ERROR("couldn't initialize FT2232 with 'stm32stick' layout");
2374 return ERROR_JTAG_INIT_FAILED;
2375 }
2376
2377 return ERROR_OK;
2378 }
2379
2380
2381 static int sheevaplug_init(void)
2382 {
2383 u8 buf[3];
2384 u32 bytes_written;
2385
2386 low_output = 0x08;
2387 low_direction = 0x1b;
2388
2389 /* initialize low byte for jtag */
2390 buf[0] = 0x80; /* command "set data bits low byte" */
2391 buf[1] = low_output; /* value (TMS=1,TCK=0, TDI=0, nOE=0) */
2392 buf[2] = low_direction; /* dir (output=1), TCK/TDI/TMS=out, TDO=in */
2393 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2394
2395 if (((ft2232_write(buf, 3, &bytes_written)) != ERROR_OK) || (bytes_written != 3))
2396 {
2397 LOG_ERROR("couldn't initialize FT2232 with 'sheevaplug' layout");
2398 return ERROR_JTAG_INIT_FAILED;
2399 }
2400
2401 nTRSTnOE = 0x1;
2402 nTRST = 0x02;
2403 nSRSTnOE = 0x4;
2404 nSRST = 0x08;
2405
2406 high_output = 0x0;
2407 high_direction = 0x0f;
2408
2409 /* nTRST is always push-pull */
2410 high_output &= ~nTRSTnOE;
2411 high_output |= nTRST;
2412
2413 /* nSRST is always open-drain */
2414 high_output |= nSRSTnOE;
2415 high_output &= ~nSRST;
2416
2417 /* initialize high port */
2418 buf[0] = 0x82; /* command "set data bits high byte" */
2419 buf[1] = high_output; /* value */
2420 buf[2] = high_direction; /* all outputs - xRST */
2421 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2422
2423 if (((ft2232_write(buf, 3, &bytes_written)) != ERROR_OK) || (bytes_written != 3))
2424 {
2425 LOG_ERROR("couldn't initialize FT2232 with 'sheevaplug' layout");
2426 return ERROR_JTAG_INIT_FAILED;
2427 }
2428
2429 return ERROR_OK;
2430 }
2431
2432 static void olimex_jtag_blink(void)
2433 {
2434 /* Olimex ARM-USB-OCD has a LED connected to ACBUS3
2435 * ACBUS3 is bit 3 of the GPIOH port
2436 */
2437 if (high_output & 0x08)
2438 {
2439 /* set port pin high */
2440 high_output &= 0x07;
2441 }
2442 else
2443 {
2444 /* set port pin low */
2445 high_output |= 0x08;
2446 }
2447
2448 BUFFER_ADD = 0x82;
2449 BUFFER_ADD = high_output;
2450 BUFFER_ADD = high_direction;
2451 }
2452
2453
2454 static void flyswatter_jtag_blink(void)
2455 {
2456 /*
2457 * Flyswatter has two LEDs connected to ACBUS2 and ACBUS3
2458 */
2459 high_output ^= 0x0c;
2460
2461 BUFFER_ADD = 0x82;
2462 BUFFER_ADD = high_output;
2463 BUFFER_ADD = high_direction;
2464 }
2465
2466
2467 static void turtle_jtag_blink(void)
2468 {
2469 /*
2470 * Turtelizer2 has two LEDs connected to ACBUS2 and ACBUS3
2471 */
2472 if (high_output & 0x08)
2473 {
2474 high_output = 0x04;
2475 }
2476 else
2477 {
2478 high_output = 0x08;
2479 }
2480
2481 BUFFER_ADD = 0x82;
2482 BUFFER_ADD = high_output;
2483 BUFFER_ADD = high_direction;
2484 }
2485
2486
2487 static int ft2232_quit(void)
2488 {
2489 #if BUILD_FT2232_FTD2XX == 1
2490 FT_STATUS status;
2491
2492 status = FT_Close(ftdih);
2493 #elif BUILD_FT2232_LIBFTDI == 1
2494 ftdi_disable_bitbang(&ftdic);
2495
2496 ftdi_usb_close(&ftdic);
2497
2498 ftdi_deinit(&ftdic);
2499 #endif
2500
2501 free(ft2232_buffer);
2502 ft2232_buffer = NULL;
2503
2504 return ERROR_OK;
2505 }
2506
2507
2508 static int ft2232_handle_device_desc_command(struct command_context_s* cmd_ctx, char* cmd, char** args, int argc)
2509 {
2510 char *cp;
2511 char buf[200];
2512 if (argc == 1)
2513 {
2514 ft2232_device_desc = strdup(args[0]);
2515 cp = strchr( ft2232_device_desc, 0 );
2516 // under Win32, the FTD2XX driver appends an "A" to the end
2517 // of the description, this examines the given desc
2518 // and creates the 'missing' _A or non_A variable.
2519 if( (cp[-1] == 'A') && (cp[-2]==' ') ){
2520 // it was, so make this the "A" version.
2521 ft2232_device_desc_A = ft2232_device_desc;
2522 // and *CREATE* the non-A version.
2523 strcpy( buf, ft2232_device_desc );
2524 cp = strchr( buf, 0 );
2525 cp[-2] = 0;
2526 ft2232_device_desc = strdup( buf );
2527 } else {
2528 // <space>A not defined
2529 // so create it
2530 sprintf( buf, "%s A", ft2232_device_desc );
2531 ft2232_device_desc_A = strdup( buf );
2532 }
2533 }
2534 else
2535 {
2536 LOG_ERROR("expected exactly one argument to ft2232_device_desc <description>");
2537 }
2538
2539 return ERROR_OK;
2540 }
2541
2542
2543 static int ft2232_handle_serial_command(struct command_context_s* cmd_ctx, char* cmd, char** args, int argc)
2544 {
2545 if (argc == 1)
2546 {
2547 ft2232_serial = strdup(args[0]);
2548 }
2549 else
2550 {
2551 LOG_ERROR("expected exactly one argument to ft2232_serial <serial-number>");
2552 }
2553
2554 return ERROR_OK;
2555 }
2556
2557
2558 static int ft2232_handle_layout_command(struct command_context_s* cmd_ctx, char* cmd, char** args, int argc)
2559 {
2560 if (argc == 0)
2561 return ERROR_OK;
2562
2563 ft2232_layout = malloc(strlen(args[0]) + 1);
2564 strcpy(ft2232_layout, args[0]);
2565
2566 return ERROR_OK;
2567 }
2568
2569
2570 static int ft2232_handle_vid_pid_command(struct command_context_s* cmd_ctx, char* cmd, char** args, int argc)
2571 {
2572 int i;
2573
2574 if (argc > MAX_USB_IDS * 2)
2575 {
2576 LOG_WARNING("ignoring extra IDs in ft2232_vid_pid "
2577 "(maximum is %d pairs)", MAX_USB_IDS);
2578 argc = MAX_USB_IDS * 2;
2579 }
2580 if ( argc < 2 || (argc & 1) )
2581 {
2582 LOG_WARNING("incomplete ft2232_vid_pid configuration directive");
2583 if (argc < 2)
2584 return ERROR_OK;
2585 }
2586
2587 for (i = 0; i + 1 < argc; i += 2)
2588 {
2589 ft2232_vid[i >> 1] = strtol(args[i], NULL, 0);
2590 ft2232_pid[i >> 1] = strtol(args[i + 1], NULL, 0);
2591 }
2592
2593 /*
2594 * Explicitly terminate, in case there are multiples instances of
2595 * ft2232_vid_pid.
2596 */
2597 ft2232_vid[i >> 1] = ft2232_pid[i >> 1] = 0;
2598
2599 return ERROR_OK;
2600 }
2601
2602
2603 static int ft2232_handle_latency_command(struct command_context_s* cmd_ctx, char* cmd, char** args, int argc)
2604 {
2605 if (argc == 1)
2606 {
2607 ft2232_latency = atoi(args[0]);
2608 }
2609 else
2610 {
2611 LOG_ERROR("expected exactly one argument to ft2232_latency <ms>");
2612 }
2613
2614 return ERROR_OK;
2615 }
2616
2617
2618 static int ft2232_stableclocks(int num_cycles, jtag_command_t* cmd)
2619 {
2620 int retval = 0;
2621
2622 /* 7 bits of either ones or zeros. */
2623 u8 tms = (tap_get_state() == TAP_RESET ? 0x7F : 0x00);
2624
2625 while (num_cycles > 0)
2626 {
2627 /* the command 0x4b, "Clock Data to TMS/CS Pin (no Read)" handles
2628 * at most 7 bits per invocation. Here we invoke it potentially
2629 * several times.
2630 */
2631 int bitcount_per_command = (num_cycles > 7) ? 7 : num_cycles;
2632
2633 if (ft2232_buffer_size + 3 >= FT2232_BUFFER_SIZE)
2634 {
2635 if (ft2232_send_and_recv(first_unsent, cmd) != ERROR_OK)
2636 retval = ERROR_JTAG_QUEUE_FAILED;
2637
2638 first_unsent = cmd;
2639 }
2640
2641 /* command "Clock Data to TMS/CS Pin (no Read)" */
2642 BUFFER_ADD = 0x4b;
2643
2644 /* scan 7 bit */
2645 BUFFER_ADD = bitcount_per_command - 1;
2646
2647 /* TMS data bits are either all zeros or ones to stay in the current stable state */
2648 BUFFER_ADD = tms;
2649
2650 require_send = 1;
2651
2652 num_cycles -= bitcount_per_command;
2653 }
2654
2655 return retval;
2656 }
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)