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 uint16_t old_output
= output
;
178 uint16_t old_direction
= direction
;
180 output
= data
? output
| s
->data_mask
: output
& ~s
->data_mask
;
181 if (s
->oe_mask
== s
->data_mask
)
182 direction
= oe
? direction
| s
->oe_mask
: direction
& ~s
->oe_mask
;
184 output
= oe
? output
| s
->oe_mask
: output
& ~s
->oe_mask
;
186 if ((output
& 0xff) != (old_output
& 0xff) || (direction
& 0xff) != (old_direction
& 0xff))
187 mpsse_set_data_bits_low_byte(mpsse_ctx
, output
& 0xff, direction
& 0xff);
188 if ((output
>> 8 != old_output
>> 8) || (direction
>> 8 != old_direction
>> 8))
189 mpsse_set_data_bits_high_byte(mpsse_ctx
, output
>> 8, direction
>> 8);
196 * Function move_to_state
197 * moves the TAP controller from the current state to a
198 * \a goal_state through a path given by tap_get_tms_path(). State transition
199 * logging is performed by delegation to clock_tms().
201 * @param goal_state is the destination state for the move.
203 static void move_to_state(tap_state_t goal_state
)
205 tap_state_t start_state
= tap_get_state();
207 /* goal_state is 1/2 of a tuple/pair of states which allow convenient
208 lookup of the required TMS pattern to move to this state from the
212 /* do the 2 lookups */
213 uint8_t tms_bits
= tap_get_tms_path(start_state
, goal_state
);
214 int tms_count
= tap_get_tms_path_len(start_state
, goal_state
);
215 assert(tms_count
<= 8);
217 DEBUG_JTAG_IO("start=%s goal=%s", tap_state_name(start_state
), tap_state_name(goal_state
));
219 /* Track state transitions step by step */
220 for (int i
= 0; i
< tms_count
; i
++)
221 tap_set_state(tap_state_transition(tap_get_state(), (tms_bits
>> i
) & 1));
223 mpsse_clock_tms_cs_out(mpsse_ctx
,
231 static int ftdi_speed(int speed
)
234 retval
= mpsse_set_frequency(mpsse_ctx
, speed
);
237 LOG_ERROR("couldn't set FTDI TCK speed");
244 static int ftdi_speed_div(int speed
, int *khz
)
250 static int ftdi_khz(int khz
, int *jtag_speed
)
252 if (khz
== 0 && !mpsse_is_high_speed(mpsse_ctx
)) {
253 LOG_DEBUG("RCLK not supported");
257 *jtag_speed
= khz
* 1000;
261 static void ftdi_end_state(tap_state_t state
)
263 if (tap_is_state_stable(state
))
264 tap_set_end_state(state
);
266 LOG_ERROR("BUG: %s is not a stable end state", tap_state_name(state
));
271 static void ftdi_execute_runtest(struct jtag_command
*cmd
)
276 DEBUG_JTAG_IO("runtest %i cycles, end in %s",
277 cmd
->cmd
.runtest
->num_cycles
,
278 tap_state_name(cmd
->cmd
.runtest
->end_state
));
280 if (tap_get_state() != TAP_IDLE
)
281 move_to_state(TAP_IDLE
);
283 /* TODO: Reuse ftdi_execute_stableclocks */
284 i
= cmd
->cmd
.runtest
->num_cycles
;
286 /* there are no state transitions in this code, so omit state tracking */
287 unsigned this_len
= i
> 7 ? 7 : i
;
288 mpsse_clock_tms_cs_out(mpsse_ctx
, &zero
, 0, this_len
, false, JTAG_MODE
);
292 ftdi_end_state(cmd
->cmd
.runtest
->end_state
);
294 if (tap_get_state() != tap_get_end_state())
295 move_to_state(tap_get_end_state());
297 DEBUG_JTAG_IO("runtest: %i, end in %s",
298 cmd
->cmd
.runtest
->num_cycles
,
299 tap_state_name(tap_get_end_state()));
302 static void ftdi_execute_statemove(struct jtag_command
*cmd
)
304 DEBUG_JTAG_IO("statemove end in %s",
305 tap_state_name(cmd
->cmd
.statemove
->end_state
));
307 ftdi_end_state(cmd
->cmd
.statemove
->end_state
);
309 /* shortest-path move to desired end state */
310 if (tap_get_state() != tap_get_end_state() || tap_get_end_state() == TAP_RESET
)
311 move_to_state(tap_get_end_state());
315 * Clock a bunch of TMS (or SWDIO) transitions, to change the JTAG
316 * (or SWD) state machine. REVISIT: Not the best method, perhaps.
318 static void ftdi_execute_tms(struct jtag_command
*cmd
)
320 DEBUG_JTAG_IO("TMS: %d bits", cmd
->cmd
.tms
->num_bits
);
322 /* TODO: Missing tap state tracking, also missing from ft2232.c! */
323 mpsse_clock_tms_cs_out(mpsse_ctx
,
326 cmd
->cmd
.tms
->num_bits
,
331 static void ftdi_execute_pathmove(struct jtag_command
*cmd
)
333 tap_state_t
*path
= cmd
->cmd
.pathmove
->path
;
334 int num_states
= cmd
->cmd
.pathmove
->num_states
;
336 DEBUG_JTAG_IO("pathmove: %i states, current: %s end: %s", num_states
,
337 tap_state_name(tap_get_state()),
338 tap_state_name(path
[num_states
-1]));
341 unsigned bit_count
= 0;
342 uint8_t tms_byte
= 0;
346 /* this loop verifies that the path is legal and logs each state in the path */
347 while (num_states
--) {
349 /* either TMS=0 or TMS=1 must work ... */
350 if (tap_state_transition(tap_get_state(), false)
351 == path
[state_count
])
352 buf_set_u32(&tms_byte
, bit_count
++, 1, 0x0);
353 else if (tap_state_transition(tap_get_state(), true)
354 == path
[state_count
]) {
355 buf_set_u32(&tms_byte
, bit_count
++, 1, 0x1);
357 /* ... or else the caller goofed BADLY */
359 LOG_ERROR("BUG: %s -> %s isn't a valid "
360 "TAP state transition",
361 tap_state_name(tap_get_state()),
362 tap_state_name(path
[state_count
]));
366 tap_set_state(path
[state_count
]);
369 if (bit_count
== 7 || num_states
== 0) {
370 mpsse_clock_tms_cs_out(mpsse_ctx
,
379 tap_set_end_state(tap_get_state());
382 static void ftdi_execute_scan(struct jtag_command
*cmd
)
384 DEBUG_JTAG_IO("%s type:%d", cmd
->cmd
.scan
->ir_scan
? "IRSCAN" : "DRSCAN",
385 jtag_scan_type(cmd
->cmd
.scan
));
387 /* Make sure there are no trailing fields with num_bits == 0, or the logic below will fail. */
388 while (cmd
->cmd
.scan
->num_fields
> 0
389 && cmd
->cmd
.scan
->fields
[cmd
->cmd
.scan
->num_fields
- 1].num_bits
== 0) {
390 cmd
->cmd
.scan
->num_fields
--;
391 LOG_DEBUG("discarding trailing empty field");
394 if (cmd
->cmd
.scan
->num_fields
== 0) {
395 LOG_DEBUG("empty scan, doing nothing");
399 if (cmd
->cmd
.scan
->ir_scan
) {
400 if (tap_get_state() != TAP_IRSHIFT
)
401 move_to_state(TAP_IRSHIFT
);
403 if (tap_get_state() != TAP_DRSHIFT
)
404 move_to_state(TAP_DRSHIFT
);
407 ftdi_end_state(cmd
->cmd
.scan
->end_state
);
409 struct scan_field
*field
= cmd
->cmd
.scan
->fields
;
410 unsigned scan_size
= 0;
412 for (int i
= 0; i
< cmd
->cmd
.scan
->num_fields
; i
++, field
++) {
413 scan_size
+= field
->num_bits
;
414 DEBUG_JTAG_IO("%s%s field %d/%d %d bits",
415 field
->in_value
? "in" : "",
416 field
->out_value
? "out" : "",
418 cmd
->cmd
.scan
->num_fields
,
421 if (i
== cmd
->cmd
.scan
->num_fields
- 1 && tap_get_state() != tap_get_end_state()) {
422 /* Last field, and we're leaving IRSHIFT/DRSHIFT. Clock last bit during tap
423 * movement. This last field can't have length zero, it was checked above. */
424 mpsse_clock_data(mpsse_ctx
,
431 uint8_t last_bit
= 0;
432 if (field
->out_value
)
433 bit_copy(&last_bit
, 0, field
->out_value
, field
->num_bits
- 1, 1);
434 uint8_t tms_bits
= 0x01;
435 mpsse_clock_tms_cs(mpsse_ctx
,
443 tap_set_state(tap_state_transition(tap_get_state(), 1));
444 mpsse_clock_tms_cs_out(mpsse_ctx
,
450 tap_set_state(tap_state_transition(tap_get_state(), 0));
452 mpsse_clock_data(mpsse_ctx
,
461 if (tap_get_state() != tap_get_end_state())
462 move_to_state(tap_get_end_state());
464 DEBUG_JTAG_IO("%s scan, %i bits, end in %s",
465 (cmd
->cmd
.scan
->ir_scan
) ? "IR" : "DR", scan_size
,
466 tap_state_name(tap_get_end_state()));
469 static void ftdi_execute_reset(struct jtag_command
*cmd
)
471 DEBUG_JTAG_IO("reset trst: %i srst %i",
472 cmd
->cmd
.reset
->trst
, cmd
->cmd
.reset
->srst
);
474 if (cmd
->cmd
.reset
->trst
== 1
475 || (cmd
->cmd
.reset
->srst
476 && (jtag_get_reset_config() & RESET_SRST_PULLS_TRST
)))
477 tap_set_state(TAP_RESET
);
479 struct signal
*trst
= find_signal_by_name("nTRST");
480 if (cmd
->cmd
.reset
->trst
== 1) {
482 ftdi_set_signal(trst
, '0');
484 LOG_ERROR("Can't assert TRST: nTRST signal is not defined");
485 } else if (trst
&& cmd
->cmd
.reset
->trst
== 0) {
486 if (jtag_get_reset_config() & RESET_TRST_OPEN_DRAIN
)
487 ftdi_set_signal(trst
, 'z');
489 ftdi_set_signal(trst
, '1');
492 struct signal
*srst
= find_signal_by_name("nSRST");
493 if (cmd
->cmd
.reset
->srst
== 1) {
495 ftdi_set_signal(srst
, '0');
497 LOG_ERROR("Can't assert SRST: nSRST signal is not defined");
498 } else if (srst
&& cmd
->cmd
.reset
->srst
== 0) {
499 if (jtag_get_reset_config() & RESET_SRST_PUSH_PULL
)
500 ftdi_set_signal(srst
, '1');
502 ftdi_set_signal(srst
, 'z');
505 DEBUG_JTAG_IO("trst: %i, srst: %i",
506 cmd
->cmd
.reset
->trst
, cmd
->cmd
.reset
->srst
);
509 static void ftdi_execute_sleep(struct jtag_command
*cmd
)
511 DEBUG_JTAG_IO("sleep %" PRIi32
, cmd
->cmd
.sleep
->us
);
513 mpsse_flush(mpsse_ctx
);
514 jtag_sleep(cmd
->cmd
.sleep
->us
);
515 DEBUG_JTAG_IO("sleep %" PRIi32
" usec while in %s",
517 tap_state_name(tap_get_state()));
520 static void ftdi_execute_stableclocks(struct jtag_command
*cmd
)
522 /* this is only allowed while in a stable state. A check for a stable
523 * state was done in jtag_add_clocks()
525 int num_cycles
= cmd
->cmd
.stableclocks
->num_cycles
;
527 /* 7 bits of either ones or zeros. */
528 uint8_t tms
= tap_get_state() == TAP_RESET
? 0x7f : 0x00;
530 /* TODO: Use mpsse_clock_data with in=out=0 for this, if TMS can be set to
531 * the correct level and remain there during the scan */
532 while (num_cycles
> 0) {
533 /* there are no state transitions in this code, so omit state tracking */
534 unsigned this_len
= num_cycles
> 7 ? 7 : num_cycles
;
535 mpsse_clock_tms_cs_out(mpsse_ctx
, &tms
, 0, this_len
, false, JTAG_MODE
);
536 num_cycles
-= this_len
;
539 DEBUG_JTAG_IO("clocks %i while in %s",
540 cmd
->cmd
.stableclocks
->num_cycles
,
541 tap_state_name(tap_get_state()));
544 static void ftdi_execute_command(struct jtag_command
*cmd
)
548 ftdi_execute_reset(cmd
);
551 ftdi_execute_runtest(cmd
);
554 ftdi_execute_statemove(cmd
);
557 ftdi_execute_pathmove(cmd
);
560 ftdi_execute_scan(cmd
);
563 ftdi_execute_sleep(cmd
);
565 case JTAG_STABLECLOCKS
:
566 ftdi_execute_stableclocks(cmd
);
569 ftdi_execute_tms(cmd
);
572 LOG_ERROR("BUG: unknown JTAG command type encountered: %d", cmd
->type
);
577 static int ftdi_execute_queue(void)
579 /* blink, if the current layout has that feature */
580 struct signal
*led
= find_signal_by_name("LED");
582 ftdi_set_signal(led
, '1');
584 for (struct jtag_command
*cmd
= jtag_command_queue
; cmd
; cmd
= cmd
->next
) {
585 /* fill the write buffer with the desired command */
586 ftdi_execute_command(cmd
);
590 ftdi_set_signal(led
, '0');
592 int retval
= mpsse_flush(mpsse_ctx
);
593 if (retval
!= ERROR_OK
)
594 LOG_ERROR("error while flushing MPSSE queue: %d", retval
);
599 static int ftdi_initialize(void)
601 if (tap_get_tms_path_len(TAP_IRPAUSE
, TAP_IRPAUSE
) == 7)
602 LOG_DEBUG("ftdi interface using 7 step jtag state transitions");
604 LOG_DEBUG("ftdi interface using shortest path jtag state transitions");
606 for (int i
= 0; ftdi_vid
[i
] || ftdi_pid
[i
]; i
++) {
607 mpsse_ctx
= mpsse_open(&ftdi_vid
[i
], &ftdi_pid
[i
], ftdi_device_desc
,
608 ftdi_serial
, ftdi_channel
);
614 return ERROR_JTAG_INIT_FAILED
;
616 mpsse_set_data_bits_low_byte(mpsse_ctx
, output
& 0xff, direction
& 0xff);
617 mpsse_set_data_bits_high_byte(mpsse_ctx
, output
>> 8, direction
>> 8);
619 mpsse_loopback_config(mpsse_ctx
, false);
621 return mpsse_flush(mpsse_ctx
);
624 static int ftdi_quit(void)
626 mpsse_close(mpsse_ctx
);
631 COMMAND_HANDLER(ftdi_handle_device_desc_command
)
634 if (ftdi_device_desc
)
635 free(ftdi_device_desc
);
636 ftdi_device_desc
= strdup(CMD_ARGV
[0]);
638 LOG_ERROR("expected exactly one argument to ftdi_device_desc <description>");
644 COMMAND_HANDLER(ftdi_handle_serial_command
)
649 ftdi_serial
= strdup(CMD_ARGV
[0]);
651 return ERROR_COMMAND_SYNTAX_ERROR
;
657 COMMAND_HANDLER(ftdi_handle_channel_command
)
660 COMMAND_PARSE_NUMBER(u8
, CMD_ARGV
[0], ftdi_channel
);
662 return ERROR_COMMAND_SYNTAX_ERROR
;
667 COMMAND_HANDLER(ftdi_handle_layout_init_command
)
670 return ERROR_COMMAND_SYNTAX_ERROR
;
672 COMMAND_PARSE_NUMBER(u16
, CMD_ARGV
[0], output
);
673 COMMAND_PARSE_NUMBER(u16
, CMD_ARGV
[1], direction
);
678 COMMAND_HANDLER(ftdi_handle_layout_signal_command
)
681 return ERROR_COMMAND_SYNTAX_ERROR
;
683 bool invert_data
= false;
684 uint16_t data_mask
= 0;
685 bool invert_oe
= false;
686 uint16_t oe_mask
= 0;
687 for (unsigned i
= 1; i
< CMD_ARGC
; i
+= 2) {
688 if (strcmp("-data", CMD_ARGV
[i
]) == 0) {
690 COMMAND_PARSE_NUMBER(u16
, CMD_ARGV
[i
+ 1], data_mask
);
691 } else if (strcmp("-ndata", CMD_ARGV
[i
]) == 0) {
693 COMMAND_PARSE_NUMBER(u16
, CMD_ARGV
[i
+ 1], data_mask
);
694 } else if (strcmp("-oe", CMD_ARGV
[i
]) == 0) {
696 COMMAND_PARSE_NUMBER(u16
, CMD_ARGV
[i
+ 1], oe_mask
);
697 } else if (strcmp("-noe", CMD_ARGV
[i
]) == 0) {
699 COMMAND_PARSE_NUMBER(u16
, CMD_ARGV
[i
+ 1], oe_mask
);
701 LOG_ERROR("unknown option '%s'", CMD_ARGV
[i
]);
702 return ERROR_COMMAND_SYNTAX_ERROR
;
707 sig
= find_signal_by_name(CMD_ARGV
[0]);
709 sig
= create_signal(CMD_ARGV
[0]);
711 LOG_ERROR("failed to create signal %s", CMD_ARGV
[0]);
715 sig
->invert_data
= invert_data
;
716 sig
->data_mask
= data_mask
;
717 sig
->invert_oe
= invert_oe
;
718 sig
->oe_mask
= oe_mask
;
723 COMMAND_HANDLER(ftdi_handle_set_signal_command
)
726 return ERROR_COMMAND_SYNTAX_ERROR
;
729 sig
= find_signal_by_name(CMD_ARGV
[0]);
731 LOG_ERROR("interface configuration doesn't define signal '%s'", CMD_ARGV
[0]);
735 switch (*CMD_ARGV
[1]) {
740 /* single character level specifier only */
741 if (CMD_ARGV
[1][1] == '\0') {
742 ftdi_set_signal(sig
, *CMD_ARGV
[1]);
746 LOG_ERROR("unknown signal level '%s', use 0, 1 or z", CMD_ARGV
[1]);
747 return ERROR_COMMAND_SYNTAX_ERROR
;
750 return mpsse_flush(mpsse_ctx
);
753 COMMAND_HANDLER(ftdi_handle_vid_pid_command
)
755 if (CMD_ARGC
> MAX_USB_IDS
* 2) {
756 LOG_WARNING("ignoring extra IDs in ftdi_vid_pid "
757 "(maximum is %d pairs)", MAX_USB_IDS
);
758 CMD_ARGC
= MAX_USB_IDS
* 2;
760 if (CMD_ARGC
< 2 || (CMD_ARGC
& 1)) {
761 LOG_WARNING("incomplete ftdi_vid_pid configuration directive");
763 return ERROR_COMMAND_SYNTAX_ERROR
;
764 /* remove the incomplete trailing id */
769 for (i
= 0; i
< CMD_ARGC
; i
+= 2) {
770 COMMAND_PARSE_NUMBER(u16
, CMD_ARGV
[i
], ftdi_vid
[i
>> 1]);
771 COMMAND_PARSE_NUMBER(u16
, CMD_ARGV
[i
+ 1], ftdi_pid
[i
>> 1]);
775 * Explicitly terminate, in case there are multiples instances of
778 ftdi_vid
[i
>> 1] = ftdi_pid
[i
>> 1] = 0;
783 static const struct command_registration ftdi_command_handlers
[] = {
785 .name
= "ftdi_device_desc",
786 .handler
= &ftdi_handle_device_desc_command
,
787 .mode
= COMMAND_CONFIG
,
788 .help
= "set the USB device description of the FTDI device",
789 .usage
= "description_string",
792 .name
= "ftdi_serial",
793 .handler
= &ftdi_handle_serial_command
,
794 .mode
= COMMAND_CONFIG
,
795 .help
= "set the serial number of the FTDI device",
796 .usage
= "serial_string",
799 .name
= "ftdi_channel",
800 .handler
= &ftdi_handle_channel_command
,
801 .mode
= COMMAND_CONFIG
,
802 .help
= "set the channel of the FTDI device that is used as JTAG",
806 .name
= "ftdi_layout_init",
807 .handler
= &ftdi_handle_layout_init_command
,
808 .mode
= COMMAND_CONFIG
,
809 .help
= "initialize the FTDI GPIO signals used "
810 "to control output-enables and reset signals",
811 .usage
= "data direction",
814 .name
= "ftdi_layout_signal",
815 .handler
= &ftdi_handle_layout_signal_command
,
817 .help
= "define a signal controlled by one or more FTDI GPIO as data "
818 "and/or output enable",
819 .usage
= "name [-data mask|-ndata mask] [-oe mask|-noe mask]",
822 .name
= "ftdi_set_signal",
823 .handler
= &ftdi_handle_set_signal_command
,
824 .mode
= COMMAND_EXEC
,
825 .help
= "control a layout-specific signal",
826 .usage
= "name (1|0|z)",
829 .name
= "ftdi_vid_pid",
830 .handler
= &ftdi_handle_vid_pid_command
,
831 .mode
= COMMAND_CONFIG
,
832 .help
= "the vendor ID and product ID of the FTDI device",
833 .usage
= "(vid pid)* ",
835 COMMAND_REGISTRATION_DONE
838 struct jtag_interface ftdi_interface
= {
840 .supported
= DEBUG_CAP_TMS_SEQ
,
841 .commands
= ftdi_command_handlers
,
842 .transports
= jtag_only
,
844 .init
= ftdi_initialize
,
847 .speed_div
= ftdi_speed_div
,
849 .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)