1 /**************************************************************************
2 * Copyright (C) 2012 by Andreas Fritiofson *
3 * andreas.fritiofson@gmail.com *
5 * This program is free software; you can redistribute it and/or modify *
6 * it under the terms of the GNU General Public License as published by *
7 * the Free Software Foundation; either version 2 of the License, or *
8 * (at your option) any later version. *
10 * This program is distributed in the hope that it will be useful, *
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
13 * GNU General Public License for more details. *
15 * You should have received a copy of the GNU General Public License *
16 * along with this program; if not, write to the *
17 * Free Software Foundation, Inc., *
18 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. *
19 ***************************************************************************/
23 * JTAG adapters based on the FT2232 full and high speed USB parts are
24 * popular low cost JTAG debug solutions. Many FT2232 based JTAG adapters
25 * are discrete, but development boards may integrate them as alternatives
26 * to more capable (and expensive) third party JTAG pods.
28 * JTAG uses only one of the two communications channels ("MPSSE engines")
29 * on these devices. Adapters based on FT4232 parts have four ports/channels
30 * (A/B/C/D), instead of just two (A/B).
32 * Especially on development boards integrating one of these chips (as
33 * opposed to discrete pods/dongles), the additional channels can be used
34 * for a variety of purposes, but OpenOCD only uses one channel at a time.
36 * - As a USB-to-serial adapter for the target's console UART ...
37 * which may be able to support ROM boot loaders that load initial
38 * firmware images to flash (or SRAM).
40 * - On systems which support ARM's SWD in addition to JTAG, or instead
41 * of it, that second port can be used for reading SWV/SWO trace data.
43 * - Additional JTAG links, e.g. to a CPLD or * FPGA.
45 * FT2232 based JTAG adapters are "dumb" not "smart", because most JTAG
46 * request/response interactions involve round trips over the USB link.
47 * A "smart" JTAG adapter has intelligence close to the scan chain, so it
48 * can for example poll quickly for a status change (usually taking on the
49 * order of microseconds not milliseconds) before beginning a queued
50 * transaction which require the previous one to have completed.
52 * There are dozens of adapters of this type, differing in details which
53 * this driver needs to understand. Those "layout" details are required
54 * as part of FT2232 driver configuration.
56 * This code uses information contained in the MPSSE specification which was
58 * http://www.ftdichip.com/Documents/AppNotes/AN2232C-01_MPSSE_Cmnd.pdf
59 * Hereafter this is called the "MPSSE Spec".
61 * The datasheet for the ftdichip.com's FT2232D part is here:
62 * http://www.ftdichip.com/Documents/DataSheets/DS_FT2232D.pdf
64 * Also note the issue with code 0x4b (clock data to TMS) noted in
65 * http://developer.intra2net.com/mailarchive/html/libftdi/2009/msg00292.html
66 * which can affect longer JTAG state paths.
73 /* project specific includes */
74 #include <jtag/interface.h>
75 #include <transport/transport.h>
76 #include <helper/time_support.h>
84 /* FTDI access library includes */
87 #define JTAG_MODE (LSB_FIRST | POS_EDGE_IN | NEG_EDGE_OUT)
89 static char *ftdi_device_desc
;
90 static char *ftdi_serial
;
91 static uint8_t ftdi_channel
;
94 /* vid = pid = 0 marks the end of the list */
95 static uint16_t ftdi_vid
[MAX_USB_IDS
+ 1] = { 0 };
96 static uint16_t ftdi_pid
[MAX_USB_IDS
+ 1] = { 0 };
98 static struct mpsse_ctx
*mpsse_ctx
;
109 static struct signal
*signals
;
111 static uint16_t output
;
112 static uint16_t direction
;
114 static struct signal
*find_signal_by_name(const char *name
)
116 for (struct signal
*sig
= signals
; sig
; sig
= sig
->next
) {
117 if (strcmp(name
, sig
->name
) == 0)
123 static struct signal
*create_signal(const char *name
)
125 struct signal
**psig
= &signals
;
127 psig
= &(*psig
)->next
;
129 *psig
= calloc(1, sizeof(**psig
));
133 (*psig
)->name
= strdup(name
);
134 if ((*psig
)->name
== NULL
) {
141 static int ftdi_set_signal(const struct signal
*s
, char value
)
146 if (s
->data_mask
== 0 && s
->oe_mask
== 0) {
147 LOG_ERROR("interface doesn't provide signal '%s'", s
->name
);
152 data
= s
->invert_data
;
156 if (s
->data_mask
== 0) {
157 LOG_ERROR("interface can't drive '%s' high", s
->name
);
160 data
= !s
->invert_data
;
165 if (s
->oe_mask
== 0) {
166 LOG_ERROR("interface can't tri-state '%s'", s
->name
);
169 data
= s
->invert_data
;
173 assert(0 && "invalid signal level specifier");
177 output
= data
? output
| s
->data_mask
: output
& ~s
->data_mask
;
178 if (s
->oe_mask
== s
->data_mask
)
179 direction
= oe
? direction
| s
->oe_mask
: direction
& ~s
->oe_mask
;
181 output
= oe
? output
| s
->oe_mask
: output
& ~s
->oe_mask
;
183 mpsse_set_data_bits_low_byte(mpsse_ctx
, output
& 0xff, direction
& 0xff);
184 mpsse_set_data_bits_high_byte(mpsse_ctx
, output
>> 8, direction
>> 8);
191 * Function move_to_state
192 * moves the TAP controller from the current state to a
193 * \a goal_state through a path given by tap_get_tms_path(). State transition
194 * logging is performed by delegation to clock_tms().
196 * @param goal_state is the destination state for the move.
198 static void move_to_state(tap_state_t goal_state
)
200 tap_state_t start_state
= tap_get_state();
202 /* goal_state is 1/2 of a tuple/pair of states which allow convenient
203 lookup of the required TMS pattern to move to this state from the
207 /* do the 2 lookups */
208 uint8_t tms_bits
= tap_get_tms_path(start_state
, goal_state
);
209 int tms_count
= tap_get_tms_path_len(start_state
, goal_state
);
210 assert(tms_count
<= 8);
212 DEBUG_JTAG_IO("start=%s goal=%s", tap_state_name(start_state
), tap_state_name(goal_state
));
214 /* Track state transitions step by step */
215 for (int i
= 0; i
< tms_count
; i
++)
216 tap_set_state(tap_state_transition(tap_get_state(), (tms_bits
>> i
) & 1));
218 mpsse_clock_tms_cs_out(mpsse_ctx
,
226 static int ftdi_speed(int speed
)
229 retval
= mpsse_set_frequency(mpsse_ctx
, speed
);
232 LOG_ERROR("couldn't set FTDI TCK speed");
239 static int ftdi_speed_div(int speed
, int *khz
)
245 static int ftdi_khz(int khz
, int *jtag_speed
)
247 if (khz
== 0 && !mpsse_is_high_speed(mpsse_ctx
)) {
248 LOG_DEBUG("RCLK not supported");
252 *jtag_speed
= khz
* 1000;
256 static void ftdi_end_state(tap_state_t state
)
258 if (tap_is_state_stable(state
))
259 tap_set_end_state(state
);
261 LOG_ERROR("BUG: %s is not a stable end state", tap_state_name(state
));
266 static void ftdi_execute_runtest(struct jtag_command
*cmd
)
271 DEBUG_JTAG_IO("runtest %i cycles, end in %s",
272 cmd
->cmd
.runtest
->num_cycles
,
273 tap_state_name(cmd
->cmd
.runtest
->end_state
));
275 if (tap_get_state() != TAP_IDLE
)
276 move_to_state(TAP_IDLE
);
278 /* TODO: Reuse ftdi_execute_stableclocks */
279 i
= cmd
->cmd
.runtest
->num_cycles
;
281 /* there are no state transitions in this code, so omit state tracking */
282 unsigned this_len
= i
> 7 ? 7 : i
;
283 mpsse_clock_tms_cs_out(mpsse_ctx
, &zero
, 0, this_len
, false, JTAG_MODE
);
287 ftdi_end_state(cmd
->cmd
.runtest
->end_state
);
289 if (tap_get_state() != tap_get_end_state())
290 move_to_state(tap_get_end_state());
292 DEBUG_JTAG_IO("runtest: %i, end in %s",
293 cmd
->cmd
.runtest
->num_cycles
,
294 tap_state_name(tap_get_end_state()));
297 static void ftdi_execute_statemove(struct jtag_command
*cmd
)
299 DEBUG_JTAG_IO("statemove end in %s",
300 tap_state_name(cmd
->cmd
.statemove
->end_state
));
302 ftdi_end_state(cmd
->cmd
.statemove
->end_state
);
304 /* shortest-path move to desired end state */
305 if (tap_get_state() != tap_get_end_state() || tap_get_end_state() == TAP_RESET
)
306 move_to_state(tap_get_end_state());
310 * Clock a bunch of TMS (or SWDIO) transitions, to change the JTAG
311 * (or SWD) state machine. REVISIT: Not the best method, perhaps.
313 static void ftdi_execute_tms(struct jtag_command
*cmd
)
315 DEBUG_JTAG_IO("TMS: %d bits", cmd
->cmd
.tms
->num_bits
);
317 /* TODO: Missing tap state tracking, also missing from ft2232.c! */
318 mpsse_clock_tms_cs_out(mpsse_ctx
,
321 cmd
->cmd
.tms
->num_bits
,
326 static void ftdi_execute_pathmove(struct jtag_command
*cmd
)
328 tap_state_t
*path
= cmd
->cmd
.pathmove
->path
;
329 int num_states
= cmd
->cmd
.pathmove
->num_states
;
331 DEBUG_JTAG_IO("pathmove: %i states, current: %s end: %s", num_states
,
332 tap_state_name(tap_get_state()),
333 tap_state_name(path
[num_states
-1]));
336 unsigned bit_count
= 0;
337 uint8_t tms_byte
= 0;
341 /* this loop verifies that the path is legal and logs each state in the path */
342 while (num_states
--) {
344 /* either TMS=0 or TMS=1 must work ... */
345 if (tap_state_transition(tap_get_state(), false)
346 == path
[state_count
])
347 buf_set_u32(&tms_byte
, bit_count
++, 1, 0x0);
348 else if (tap_state_transition(tap_get_state(), true)
349 == path
[state_count
]) {
350 buf_set_u32(&tms_byte
, bit_count
++, 1, 0x1);
352 /* ... or else the caller goofed BADLY */
354 LOG_ERROR("BUG: %s -> %s isn't a valid "
355 "TAP state transition",
356 tap_state_name(tap_get_state()),
357 tap_state_name(path
[state_count
]));
361 tap_set_state(path
[state_count
]);
364 if (bit_count
== 7 || num_states
== 0) {
365 mpsse_clock_tms_cs_out(mpsse_ctx
,
374 tap_set_end_state(tap_get_state());
377 static void ftdi_execute_scan(struct jtag_command
*cmd
)
379 DEBUG_JTAG_IO("%s type:%d", cmd
->cmd
.scan
->ir_scan
? "IRSCAN" : "DRSCAN",
380 jtag_scan_type(cmd
->cmd
.scan
));
382 /* Make sure there are no trailing fields with num_bits == 0, or the logic below will fail. */
383 while (cmd
->cmd
.scan
->num_fields
> 0
384 && cmd
->cmd
.scan
->fields
[cmd
->cmd
.scan
->num_fields
- 1].num_bits
== 0) {
385 cmd
->cmd
.scan
->num_fields
--;
386 LOG_DEBUG("discarding trailing empty field");
389 if (cmd
->cmd
.scan
->num_fields
== 0) {
390 LOG_DEBUG("empty scan, doing nothing");
394 if (cmd
->cmd
.scan
->ir_scan
) {
395 if (tap_get_state() != TAP_IRSHIFT
)
396 move_to_state(TAP_IRSHIFT
);
398 if (tap_get_state() != TAP_DRSHIFT
)
399 move_to_state(TAP_DRSHIFT
);
402 ftdi_end_state(cmd
->cmd
.scan
->end_state
);
404 struct scan_field
*field
= cmd
->cmd
.scan
->fields
;
405 unsigned scan_size
= 0;
407 for (int i
= 0; i
< cmd
->cmd
.scan
->num_fields
; i
++, field
++) {
408 scan_size
+= field
->num_bits
;
409 DEBUG_JTAG_IO("%s%s field %d/%d %d bits",
410 field
->in_value
? "in" : "",
411 field
->out_value
? "out" : "",
413 cmd
->cmd
.scan
->num_fields
,
416 if (i
== cmd
->cmd
.scan
->num_fields
- 1 && tap_get_state() != tap_get_end_state()) {
417 /* Last field, and we're leaving IRSHIFT/DRSHIFT. Clock last bit during tap
418 * movement. This last field can't have length zero, it was checked above. */
419 mpsse_clock_data(mpsse_ctx
,
426 uint8_t last_bit
= 0;
427 if (field
->out_value
)
428 bit_copy(&last_bit
, 0, field
->out_value
, field
->num_bits
- 1, 1);
429 uint8_t tms_bits
= 0x01;
430 mpsse_clock_tms_cs(mpsse_ctx
,
438 tap_set_state(tap_state_transition(tap_get_state(), 1));
439 mpsse_clock_tms_cs_out(mpsse_ctx
,
445 tap_set_state(tap_state_transition(tap_get_state(), 0));
447 mpsse_clock_data(mpsse_ctx
,
456 if (tap_get_state() != tap_get_end_state())
457 move_to_state(tap_get_end_state());
459 DEBUG_JTAG_IO("%s scan, %i bits, end in %s",
460 (cmd
->cmd
.scan
->ir_scan
) ? "IR" : "DR", scan_size
,
461 tap_state_name(tap_get_end_state()));
464 static void ftdi_execute_reset(struct jtag_command
*cmd
)
466 DEBUG_JTAG_IO("reset trst: %i srst %i",
467 cmd
->cmd
.reset
->trst
, cmd
->cmd
.reset
->srst
);
469 if (cmd
->cmd
.reset
->trst
== 1
470 || (cmd
->cmd
.reset
->srst
471 && (jtag_get_reset_config() & RESET_SRST_PULLS_TRST
)))
472 tap_set_state(TAP_RESET
);
474 struct signal
*trst
= find_signal_by_name("nTRST");
475 if (trst
&& cmd
->cmd
.reset
->trst
== 1) {
476 ftdi_set_signal(trst
, '0');
477 } else if (trst
&& cmd
->cmd
.reset
->trst
== 0) {
478 if (jtag_get_reset_config() & RESET_TRST_OPEN_DRAIN
)
479 ftdi_set_signal(trst
, 'z');
481 ftdi_set_signal(trst
, '1');
484 struct signal
*srst
= find_signal_by_name("nSRST");
485 if (srst
&& cmd
->cmd
.reset
->srst
== 1) {
486 ftdi_set_signal(srst
, '0');
487 } else if (srst
&& cmd
->cmd
.reset
->srst
== 0) {
488 if (jtag_get_reset_config() & RESET_SRST_PUSH_PULL
)
489 ftdi_set_signal(srst
, '1');
491 ftdi_set_signal(srst
, 'z');
494 DEBUG_JTAG_IO("trst: %i, srst: %i",
495 cmd
->cmd
.reset
->trst
, cmd
->cmd
.reset
->srst
);
498 static void ftdi_execute_sleep(struct jtag_command
*cmd
)
500 DEBUG_JTAG_IO("sleep %" PRIi32
, cmd
->cmd
.sleep
->us
);
502 mpsse_flush(mpsse_ctx
);
503 jtag_sleep(cmd
->cmd
.sleep
->us
);
504 DEBUG_JTAG_IO("sleep %" PRIi32
" usec while in %s",
506 tap_state_name(tap_get_state()));
509 static void ftdi_execute_stableclocks(struct jtag_command
*cmd
)
511 /* this is only allowed while in a stable state. A check for a stable
512 * state was done in jtag_add_clocks()
514 int num_cycles
= cmd
->cmd
.stableclocks
->num_cycles
;
516 /* 7 bits of either ones or zeros. */
517 uint8_t tms
= tap_get_state() == TAP_RESET
? 0x7f : 0x00;
519 /* TODO: Use mpsse_clock_data with in=out=0 for this, if TMS can be set to
520 * the correct level and remain there during the scan */
521 while (num_cycles
> 0) {
522 /* there are no state transitions in this code, so omit state tracking */
523 unsigned this_len
= num_cycles
> 7 ? 7 : num_cycles
;
524 mpsse_clock_tms_cs_out(mpsse_ctx
, &tms
, 0, this_len
, false, JTAG_MODE
);
525 num_cycles
-= this_len
;
528 DEBUG_JTAG_IO("clocks %i while in %s",
529 cmd
->cmd
.stableclocks
->num_cycles
,
530 tap_state_name(tap_get_state()));
533 static void ftdi_execute_command(struct jtag_command
*cmd
)
537 ftdi_execute_reset(cmd
);
540 ftdi_execute_runtest(cmd
);
543 ftdi_execute_statemove(cmd
);
546 ftdi_execute_pathmove(cmd
);
549 ftdi_execute_scan(cmd
);
552 ftdi_execute_sleep(cmd
);
554 case JTAG_STABLECLOCKS
:
555 ftdi_execute_stableclocks(cmd
);
558 ftdi_execute_tms(cmd
);
561 LOG_ERROR("BUG: unknown JTAG command type encountered: %d", cmd
->type
);
566 static int ftdi_execute_queue(void)
568 /* blink, if the current layout has that feature */
569 struct signal
*led
= find_signal_by_name("LED");
571 ftdi_set_signal(led
, '1');
573 for (struct jtag_command
*cmd
= jtag_command_queue
; cmd
; cmd
= cmd
->next
) {
574 /* fill the write buffer with the desired command */
575 ftdi_execute_command(cmd
);
579 ftdi_set_signal(led
, '0');
581 int retval
= mpsse_flush(mpsse_ctx
);
582 if (retval
!= ERROR_OK
)
583 LOG_ERROR("error while flushing MPSSE queue: %d", retval
);
588 static int ftdi_initialize(void)
590 if (tap_get_tms_path_len(TAP_IRPAUSE
, TAP_IRPAUSE
) == 7)
591 LOG_DEBUG("ftdi interface using 7 step jtag state transitions");
593 LOG_DEBUG("ftdi interface using shortest path jtag state transitions");
595 for (int i
= 0; ftdi_vid
[i
] || ftdi_pid
[i
]; i
++) {
596 mpsse_ctx
= mpsse_open(&ftdi_vid
[i
], &ftdi_pid
[i
], ftdi_device_desc
,
597 ftdi_serial
, ftdi_channel
);
603 return ERROR_JTAG_INIT_FAILED
;
605 mpsse_set_data_bits_low_byte(mpsse_ctx
, output
& 0xff, direction
& 0xff);
606 mpsse_set_data_bits_high_byte(mpsse_ctx
, output
>> 8, direction
>> 8);
608 mpsse_loopback_config(mpsse_ctx
, false);
610 return mpsse_flush(mpsse_ctx
);
613 static int ftdi_quit(void)
615 mpsse_close(mpsse_ctx
);
620 COMMAND_HANDLER(ftdi_handle_device_desc_command
)
623 if (ftdi_device_desc
)
624 free(ftdi_device_desc
);
625 ftdi_device_desc
= strdup(CMD_ARGV
[0]);
627 LOG_ERROR("expected exactly one argument to ftdi_device_desc <description>");
633 COMMAND_HANDLER(ftdi_handle_serial_command
)
638 ftdi_serial
= strdup(CMD_ARGV
[0]);
640 return ERROR_COMMAND_SYNTAX_ERROR
;
646 COMMAND_HANDLER(ftdi_handle_channel_command
)
649 COMMAND_PARSE_NUMBER(u8
, CMD_ARGV
[0], ftdi_channel
);
651 return ERROR_COMMAND_SYNTAX_ERROR
;
656 COMMAND_HANDLER(ftdi_handle_layout_init_command
)
659 return ERROR_COMMAND_SYNTAX_ERROR
;
661 COMMAND_PARSE_NUMBER(u16
, CMD_ARGV
[0], output
);
662 COMMAND_PARSE_NUMBER(u16
, CMD_ARGV
[1], direction
);
667 COMMAND_HANDLER(ftdi_handle_layout_signal_command
)
670 return ERROR_COMMAND_SYNTAX_ERROR
;
672 bool invert_data
= false;
673 uint16_t data_mask
= 0;
674 bool invert_oe
= false;
675 uint16_t oe_mask
= 0;
676 for (unsigned i
= 1; i
< CMD_ARGC
; i
+= 2) {
677 if (strcmp("-data", CMD_ARGV
[i
]) == 0) {
679 COMMAND_PARSE_NUMBER(u16
, CMD_ARGV
[i
+ 1], data_mask
);
680 } else if (strcmp("-ndata", CMD_ARGV
[i
]) == 0) {
682 COMMAND_PARSE_NUMBER(u16
, CMD_ARGV
[i
+ 1], data_mask
);
683 } else if (strcmp("-oe", CMD_ARGV
[i
]) == 0) {
685 COMMAND_PARSE_NUMBER(u16
, CMD_ARGV
[i
+ 1], oe_mask
);
686 } else if (strcmp("-noe", CMD_ARGV
[i
]) == 0) {
688 COMMAND_PARSE_NUMBER(u16
, CMD_ARGV
[i
+ 1], oe_mask
);
690 LOG_ERROR("unknown option '%s'", CMD_ARGV
[i
]);
691 return ERROR_COMMAND_SYNTAX_ERROR
;
696 sig
= find_signal_by_name(CMD_ARGV
[0]);
698 sig
= create_signal(CMD_ARGV
[0]);
700 LOG_ERROR("failed to create signal %s", CMD_ARGV
[0]);
704 sig
->invert_data
= invert_data
;
705 sig
->data_mask
= data_mask
;
706 sig
->invert_oe
= invert_oe
;
707 sig
->oe_mask
= oe_mask
;
712 COMMAND_HANDLER(ftdi_handle_set_signal_command
)
715 return ERROR_COMMAND_SYNTAX_ERROR
;
718 sig
= find_signal_by_name(CMD_ARGV
[0]);
720 LOG_ERROR("interface configuration doesn't define signal '%s'", CMD_ARGV
[0]);
724 switch (*CMD_ARGV
[1]) {
729 /* single character level specifier only */
730 if (CMD_ARGV
[1][1] == '\0') {
731 ftdi_set_signal(sig
, *CMD_ARGV
[1]);
735 LOG_ERROR("unknown signal level '%s', use 0, 1 or z", CMD_ARGV
[1]);
736 return ERROR_COMMAND_SYNTAX_ERROR
;
739 return mpsse_flush(mpsse_ctx
);
742 COMMAND_HANDLER(ftdi_handle_vid_pid_command
)
744 if (CMD_ARGC
> MAX_USB_IDS
* 2) {
745 LOG_WARNING("ignoring extra IDs in ftdi_vid_pid "
746 "(maximum is %d pairs)", MAX_USB_IDS
);
747 CMD_ARGC
= MAX_USB_IDS
* 2;
749 if (CMD_ARGC
< 2 || (CMD_ARGC
& 1)) {
750 LOG_WARNING("incomplete ftdi_vid_pid configuration directive");
752 return ERROR_COMMAND_SYNTAX_ERROR
;
753 /* remove the incomplete trailing id */
758 for (i
= 0; i
< CMD_ARGC
; i
+= 2) {
759 COMMAND_PARSE_NUMBER(u16
, CMD_ARGV
[i
], ftdi_vid
[i
>> 1]);
760 COMMAND_PARSE_NUMBER(u16
, CMD_ARGV
[i
+ 1], ftdi_pid
[i
>> 1]);
764 * Explicitly terminate, in case there are multiples instances of
767 ftdi_vid
[i
>> 1] = ftdi_pid
[i
>> 1] = 0;
772 static const struct command_registration ftdi_command_handlers
[] = {
774 .name
= "ftdi_device_desc",
775 .handler
= &ftdi_handle_device_desc_command
,
776 .mode
= COMMAND_CONFIG
,
777 .help
= "set the USB device description of the FTDI device",
778 .usage
= "description_string",
781 .name
= "ftdi_serial",
782 .handler
= &ftdi_handle_serial_command
,
783 .mode
= COMMAND_CONFIG
,
784 .help
= "set the serial number of the FTDI device",
785 .usage
= "serial_string",
788 .name
= "ftdi_channel",
789 .handler
= &ftdi_handle_channel_command
,
790 .mode
= COMMAND_CONFIG
,
791 .help
= "set the channel of the FTDI device that is used as JTAG",
795 .name
= "ftdi_layout_init",
796 .handler
= &ftdi_handle_layout_init_command
,
797 .mode
= COMMAND_CONFIG
,
798 .help
= "initialize the FTDI GPIO signals used "
799 "to control output-enables and reset signals",
800 .usage
= "data direction",
803 .name
= "ftdi_layout_signal",
804 .handler
= &ftdi_handle_layout_signal_command
,
806 .help
= "define a signal controlled by one or more FTDI GPIO as data "
807 "and/or output enable",
808 .usage
= "name [-data mask|-ndata mask] [-oe mask|-noe mask]",
811 .name
= "ftdi_set_signal",
812 .handler
= &ftdi_handle_set_signal_command
,
813 .mode
= COMMAND_EXEC
,
814 .help
= "control a layout-specific signal",
815 .usage
= "name (1|0|z)",
818 .name
= "ftdi_vid_pid",
819 .handler
= &ftdi_handle_vid_pid_command
,
820 .mode
= COMMAND_CONFIG
,
821 .help
= "the vendor ID and product ID of the FTDI device",
822 .usage
= "(vid pid)* ",
824 COMMAND_REGISTRATION_DONE
827 struct jtag_interface ftdi_interface
= {
829 .supported
= DEBUG_CAP_TMS_SEQ
,
830 .commands
= ftdi_command_handlers
,
831 .transports
= jtag_only
,
833 .init
= ftdi_initialize
,
836 .speed_div
= ftdi_speed_div
,
838 .execute_queue
= ftdi_execute_queue
,
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)