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
)
147 if (s
->data_mask
== 0 && s
->oe_mask
== 0) {
148 LOG_ERROR("interface doesn't provide signal '%s'", s
->name
);
153 data
= s
->invert_data
;
157 if (s
->data_mask
== 0) {
158 LOG_ERROR("interface can't drive '%s' high", s
->name
);
161 data
= !s
->invert_data
;
166 if (s
->oe_mask
== 0) {
167 LOG_ERROR("interface can't tri-state '%s'", s
->name
);
170 data
= s
->invert_data
;
174 assert(0 && "invalid signal level specifier");
178 output
= data
? output
| s
->data_mask
: output
& ~s
->data_mask
;
179 if (s
->oe_mask
== s
->data_mask
)
180 direction
= oe
? direction
| s
->oe_mask
: direction
& ~s
->oe_mask
;
182 output
= oe
? output
| s
->oe_mask
: output
& ~s
->oe_mask
;
184 retval
= mpsse_set_data_bits_low_byte(mpsse_ctx
, output
& 0xff, direction
& 0xff);
185 if (retval
== ERROR_OK
)
186 retval
= mpsse_set_data_bits_high_byte(mpsse_ctx
, output
>> 8, direction
>> 8);
187 if (retval
!= ERROR_OK
) {
188 LOG_ERROR("couldn't initialize FTDI GPIO");
189 return ERROR_JTAG_INIT_FAILED
;
197 * Function move_to_state
198 * moves the TAP controller from the current state to a
199 * \a goal_state through a path given by tap_get_tms_path(). State transition
200 * logging is performed by delegation to clock_tms().
202 * @param goal_state is the destination state for the move.
204 static int move_to_state(tap_state_t goal_state
)
206 tap_state_t start_state
= tap_get_state();
208 /* goal_state is 1/2 of a tuple/pair of states which allow convenient
209 lookup of the required TMS pattern to move to this state from the
213 /* do the 2 lookups */
214 int tms_bits
= tap_get_tms_path(start_state
, goal_state
);
215 int tms_count
= tap_get_tms_path_len(start_state
, goal_state
);
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 return mpsse_clock_tms_cs_out(mpsse_ctx
,
224 (uint8_t *)&tms_bits
,
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 int ftdi_execute_runtest(struct jtag_command
*cmd
)
273 int retval
= ERROR_OK
;
277 DEBUG_JTAG_IO("runtest %i cycles, end in %s",
278 cmd
->cmd
.runtest
->num_cycles
,
279 tap_state_name(cmd
->cmd
.runtest
->end_state
));
281 if (tap_get_state() != TAP_IDLE
)
282 move_to_state(TAP_IDLE
);
284 /* TODO: Reuse ftdi_execute_stableclocks */
285 i
= cmd
->cmd
.runtest
->num_cycles
;
286 while (i
> 0 && retval
== ERROR_OK
) {
287 /* there are no state transitions in this code, so omit state tracking */
288 unsigned this_len
= i
> 7 ? 7 : i
;
289 retval
= mpsse_clock_tms_cs_out(mpsse_ctx
, &zero
, 0, this_len
, false, JTAG_MODE
);
293 ftdi_end_state(cmd
->cmd
.runtest
->end_state
);
295 if (tap_get_state() != tap_get_end_state())
296 move_to_state(tap_get_end_state());
298 DEBUG_JTAG_IO("runtest: %i, end in %s",
299 cmd
->cmd
.runtest
->num_cycles
,
300 tap_state_name(tap_get_end_state()));
304 static int ftdi_execute_statemove(struct jtag_command
*cmd
)
306 int retval
= ERROR_OK
;
308 DEBUG_JTAG_IO("statemove end in %s",
309 tap_state_name(cmd
->cmd
.statemove
->end_state
));
311 ftdi_end_state(cmd
->cmd
.statemove
->end_state
);
313 /* shortest-path move to desired end state */
314 if (tap_get_state() != tap_get_end_state() || tap_get_end_state() == TAP_RESET
)
315 move_to_state(tap_get_end_state());
321 * Clock a bunch of TMS (or SWDIO) transitions, to change the JTAG
322 * (or SWD) state machine. REVISIT: Not the best method, perhaps.
324 static int ftdi_execute_tms(struct jtag_command
*cmd
)
326 DEBUG_JTAG_IO("TMS: %d bits", cmd
->cmd
.tms
->num_bits
);
328 /* TODO: Missing tap state tracking, also missing from ft2232.c! */
329 return mpsse_clock_tms_cs_out(mpsse_ctx
,
332 cmd
->cmd
.tms
->num_bits
,
337 static int ftdi_execute_pathmove(struct jtag_command
*cmd
)
339 int retval
= ERROR_OK
;
341 tap_state_t
*path
= cmd
->cmd
.pathmove
->path
;
342 int num_states
= cmd
->cmd
.pathmove
->num_states
;
344 DEBUG_JTAG_IO("pathmove: %i states, current: %s end: %s", num_states
,
345 tap_state_name(tap_get_state()),
346 tap_state_name(path
[num_states
-1]));
349 unsigned bit_count
= 0;
350 uint8_t tms_byte
= 0;
354 /* this loop verifies that the path is legal and logs each state in the path */
355 while (num_states
-- && retval
== ERROR_OK
) {
357 /* either TMS=0 or TMS=1 must work ... */
358 if (tap_state_transition(tap_get_state(), false)
359 == path
[state_count
])
360 buf_set_u32(&tms_byte
, bit_count
++, 1, 0x0);
361 else if (tap_state_transition(tap_get_state(), true)
362 == path
[state_count
]) {
363 buf_set_u32(&tms_byte
, bit_count
++, 1, 0x1);
365 /* ... or else the caller goofed BADLY */
367 LOG_ERROR("BUG: %s -> %s isn't a valid "
368 "TAP state transition",
369 tap_state_name(tap_get_state()),
370 tap_state_name(path
[state_count
]));
374 tap_set_state(path
[state_count
]);
377 if (bit_count
== 7 || num_states
== 0) {
378 retval
= mpsse_clock_tms_cs_out(mpsse_ctx
,
387 tap_set_end_state(tap_get_state());
392 static int ftdi_execute_scan(struct jtag_command
*cmd
)
394 int retval
= ERROR_OK
;
396 DEBUG_JTAG_IO("%s type:%d", cmd
->cmd
.scan
->ir_scan
? "IRSCAN" : "DRSCAN",
397 jtag_scan_type(cmd
->cmd
.scan
));
399 /* Make sure there are no trailing fields with num_bits == 0, or the logic below will fail. */
400 while (cmd
->cmd
.scan
->num_fields
> 0
401 && cmd
->cmd
.scan
->fields
[cmd
->cmd
.scan
->num_fields
- 1].num_bits
== 0) {
402 cmd
->cmd
.scan
->num_fields
--;
403 LOG_DEBUG("discarding trailing empty field");
406 if (cmd
->cmd
.scan
->num_fields
== 0) {
407 LOG_DEBUG("empty scan, doing nothing");
411 if (cmd
->cmd
.scan
->ir_scan
) {
412 if (tap_get_state() != TAP_IRSHIFT
)
413 move_to_state(TAP_IRSHIFT
);
415 if (tap_get_state() != TAP_DRSHIFT
)
416 move_to_state(TAP_DRSHIFT
);
419 ftdi_end_state(cmd
->cmd
.scan
->end_state
);
421 struct scan_field
*field
= cmd
->cmd
.scan
->fields
;
422 unsigned scan_size
= 0;
424 for (int i
= 0; i
< cmd
->cmd
.scan
->num_fields
; i
++, field
++) {
425 scan_size
+= field
->num_bits
;
426 DEBUG_JTAG_IO("%s%s field %d/%d %d bits",
427 field
->in_value
? "in" : "",
428 field
->out_value
? "out" : "",
430 cmd
->cmd
.scan
->num_fields
,
433 if (i
== cmd
->cmd
.scan
->num_fields
- 1 && tap_get_state() != tap_get_end_state()) {
434 /* Last field, and we're leaving IRSHIFT/DRSHIFT. Clock last bit during tap
435 * movement. This last field can't have length zero, it was checked above. */
436 mpsse_clock_data(mpsse_ctx
,
443 uint8_t last_bit
= 0;
444 if (field
->out_value
)
445 bit_copy(&last_bit
, 0, field
->out_value
, field
->num_bits
- 1, 1);
446 uint8_t tms_bits
= 0x01;
447 retval
= mpsse_clock_tms_cs(mpsse_ctx
,
455 tap_set_state(tap_state_transition(tap_get_state(), 1));
456 retval
= mpsse_clock_tms_cs_out(mpsse_ctx
,
462 tap_set_state(tap_state_transition(tap_get_state(), 0));
464 mpsse_clock_data(mpsse_ctx
,
471 if (retval
!= ERROR_OK
) {
472 LOG_ERROR("failed to add field %d in scan", i
);
477 if (tap_get_state() != tap_get_end_state())
478 move_to_state(tap_get_end_state());
480 DEBUG_JTAG_IO("%s scan, %i bits, end in %s",
481 (cmd
->cmd
.scan
->ir_scan
) ? "IR" : "DR", scan_size
,
482 tap_state_name(tap_get_end_state()));
487 static int ftdi_execute_reset(struct jtag_command
*cmd
)
489 DEBUG_JTAG_IO("reset trst: %i srst %i",
490 cmd
->cmd
.reset
->trst
, cmd
->cmd
.reset
->srst
);
492 if (cmd
->cmd
.reset
->trst
== 1
493 || (cmd
->cmd
.reset
->srst
494 && (jtag_get_reset_config() & RESET_SRST_PULLS_TRST
)))
495 tap_set_state(TAP_RESET
);
497 struct signal
*trst
= find_signal_by_name("nTRST");
498 if (trst
&& cmd
->cmd
.reset
->trst
== 1) {
499 ftdi_set_signal(trst
, '0');
500 } else if (trst
&& cmd
->cmd
.reset
->trst
== 0) {
501 if (jtag_get_reset_config() & RESET_TRST_OPEN_DRAIN
)
502 ftdi_set_signal(trst
, 'z');
504 ftdi_set_signal(trst
, '1');
507 struct signal
*srst
= find_signal_by_name("nSRST");
508 if (srst
&& cmd
->cmd
.reset
->srst
== 1) {
509 ftdi_set_signal(srst
, '0');
510 } else if (srst
&& cmd
->cmd
.reset
->srst
== 0) {
511 if (jtag_get_reset_config() & RESET_SRST_PUSH_PULL
)
512 ftdi_set_signal(srst
, '1');
514 ftdi_set_signal(srst
, 'z');
517 DEBUG_JTAG_IO("trst: %i, srst: %i",
518 cmd
->cmd
.reset
->trst
, cmd
->cmd
.reset
->srst
);
522 static int ftdi_execute_sleep(struct jtag_command
*cmd
)
524 int retval
= ERROR_OK
;
526 DEBUG_JTAG_IO("sleep %" PRIi32
, cmd
->cmd
.sleep
->us
);
528 retval
= mpsse_flush(mpsse_ctx
);
529 jtag_sleep(cmd
->cmd
.sleep
->us
);
530 DEBUG_JTAG_IO("sleep %" PRIi32
" usec while in %s",
532 tap_state_name(tap_get_state()));
536 static int ftdi_execute_stableclocks(struct jtag_command
*cmd
)
538 int retval
= ERROR_OK
;
540 /* this is only allowed while in a stable state. A check for a stable
541 * state was done in jtag_add_clocks()
543 int num_cycles
= cmd
->cmd
.stableclocks
->num_cycles
;
545 /* 7 bits of either ones or zeros. */
546 uint8_t tms
= tap_get_state() == TAP_RESET
? 0x7f : 0x00;
548 /* TODO: Use mpsse_clock_data with in=out=0 for this, if TMS can be set to
549 * the correct level and remain there during the scan */
550 while (num_cycles
> 0 && retval
== ERROR_OK
) {
551 /* there are no state transitions in this code, so omit state tracking */
552 unsigned this_len
= num_cycles
> 7 ? 7 : num_cycles
;
553 retval
= mpsse_clock_tms_cs_out(mpsse_ctx
, &tms
, 0, this_len
, false, JTAG_MODE
);
554 num_cycles
-= this_len
;
557 DEBUG_JTAG_IO("clocks %i while in %s",
558 cmd
->cmd
.stableclocks
->num_cycles
,
559 tap_state_name(tap_get_state()));
563 static int ftdi_execute_command(struct jtag_command
*cmd
)
569 retval
= ftdi_execute_reset(cmd
);
572 retval
= ftdi_execute_runtest(cmd
);
575 retval
= ftdi_execute_statemove(cmd
);
578 retval
= ftdi_execute_pathmove(cmd
);
581 retval
= ftdi_execute_scan(cmd
);
584 retval
= ftdi_execute_sleep(cmd
);
586 case JTAG_STABLECLOCKS
:
587 retval
= ftdi_execute_stableclocks(cmd
);
590 retval
= ftdi_execute_tms(cmd
);
593 LOG_ERROR("BUG: unknown JTAG command type encountered: %d", cmd
->type
);
594 retval
= ERROR_JTAG_QUEUE_FAILED
;
600 static int ftdi_execute_queue(void)
602 int retval
= ERROR_OK
;
604 /* blink, if the current layout has that feature */
605 struct signal
*led
= find_signal_by_name("LED");
607 ftdi_set_signal(led
, '1');
609 for (struct jtag_command
*cmd
= jtag_command_queue
; cmd
; cmd
= cmd
->next
) {
610 /* fill the write buffer with the desired command */
611 if (ftdi_execute_command(cmd
) != ERROR_OK
)
612 retval
= ERROR_JTAG_QUEUE_FAILED
;
616 ftdi_set_signal(led
, '0');
618 retval
= mpsse_flush(mpsse_ctx
);
619 if (retval
!= ERROR_OK
)
620 LOG_ERROR("error while flushing MPSSE queue: %d", retval
);
625 static int ftdi_initialize(void)
629 if (tap_get_tms_path_len(TAP_IRPAUSE
, TAP_IRPAUSE
) == 7)
630 LOG_DEBUG("ftdi interface using 7 step jtag state transitions");
632 LOG_DEBUG("ftdi interface using shortest path jtag state transitions");
634 for (int i
= 0; ftdi_vid
[i
] || ftdi_pid
[i
]; i
++) {
635 mpsse_ctx
= mpsse_open(&ftdi_vid
[i
], &ftdi_pid
[i
], ftdi_device_desc
,
636 ftdi_serial
, ftdi_channel
);
642 return ERROR_JTAG_INIT_FAILED
;
644 retval
= mpsse_set_data_bits_low_byte(mpsse_ctx
, output
& 0xff, direction
& 0xff);
645 if (retval
== ERROR_OK
)
646 retval
= mpsse_set_data_bits_high_byte(mpsse_ctx
, output
>> 8, direction
>> 8);
647 if (retval
!= ERROR_OK
) {
648 LOG_ERROR("couldn't initialize FTDI with configured layout");
649 return ERROR_JTAG_INIT_FAILED
;
652 retval
= mpsse_loopback_config(mpsse_ctx
, false);
653 if (retval
!= ERROR_OK
) {
654 LOG_ERROR("couldn't write to FTDI to disable loopback");
655 return ERROR_JTAG_INIT_FAILED
;
658 return mpsse_flush(mpsse_ctx
);
661 static int ftdi_quit(void)
663 mpsse_close(mpsse_ctx
);
668 COMMAND_HANDLER(ftdi_handle_device_desc_command
)
671 if (ftdi_device_desc
)
672 free(ftdi_device_desc
);
673 ftdi_device_desc
= strdup(CMD_ARGV
[0]);
675 LOG_ERROR("expected exactly one argument to ftdi_device_desc <description>");
681 COMMAND_HANDLER(ftdi_handle_serial_command
)
686 ftdi_serial
= strdup(CMD_ARGV
[0]);
688 return ERROR_COMMAND_SYNTAX_ERROR
;
694 COMMAND_HANDLER(ftdi_handle_channel_command
)
697 COMMAND_PARSE_NUMBER(u8
, CMD_ARGV
[0], ftdi_channel
);
699 return ERROR_COMMAND_SYNTAX_ERROR
;
704 COMMAND_HANDLER(ftdi_handle_layout_init_command
)
707 return ERROR_COMMAND_SYNTAX_ERROR
;
709 COMMAND_PARSE_NUMBER(u16
, CMD_ARGV
[0], output
);
710 COMMAND_PARSE_NUMBER(u16
, CMD_ARGV
[1], direction
);
715 COMMAND_HANDLER(ftdi_handle_layout_signal_command
)
718 return ERROR_COMMAND_SYNTAX_ERROR
;
720 bool invert_data
= false;
721 uint16_t data_mask
= 0;
722 bool invert_oe
= false;
723 uint16_t oe_mask
= 0;
724 for (unsigned i
= 1; i
< CMD_ARGC
; i
+= 2) {
725 if (strcmp("-data", CMD_ARGV
[i
]) == 0) {
727 COMMAND_PARSE_NUMBER(u16
, CMD_ARGV
[i
+ 1], data_mask
);
728 } else if (strcmp("-ndata", CMD_ARGV
[i
]) == 0) {
730 COMMAND_PARSE_NUMBER(u16
, CMD_ARGV
[i
+ 1], data_mask
);
731 } else if (strcmp("-oe", CMD_ARGV
[i
]) == 0) {
733 COMMAND_PARSE_NUMBER(u16
, CMD_ARGV
[i
+ 1], oe_mask
);
734 } else if (strcmp("-noe", CMD_ARGV
[i
]) == 0) {
736 COMMAND_PARSE_NUMBER(u16
, CMD_ARGV
[i
+ 1], oe_mask
);
738 LOG_ERROR("unknown option '%s'", CMD_ARGV
[i
]);
739 return ERROR_COMMAND_SYNTAX_ERROR
;
744 sig
= find_signal_by_name(CMD_ARGV
[0]);
746 sig
= create_signal(CMD_ARGV
[0]);
748 LOG_ERROR("failed to create signal %s", CMD_ARGV
[0]);
752 sig
->invert_data
= invert_data
;
753 sig
->data_mask
= data_mask
;
754 sig
->invert_oe
= invert_oe
;
755 sig
->oe_mask
= oe_mask
;
760 COMMAND_HANDLER(ftdi_handle_set_signal_command
)
763 return ERROR_COMMAND_SYNTAX_ERROR
;
766 sig
= find_signal_by_name(CMD_ARGV
[0]);
768 LOG_ERROR("interface configuration doesn't define signal '%s'", CMD_ARGV
[0]);
772 switch (*CMD_ARGV
[1]) {
777 /* single character level specifier only */
778 if (CMD_ARGV
[1][1] == '\0') {
779 ftdi_set_signal(sig
, *CMD_ARGV
[1]);
783 LOG_ERROR("unknown signal level '%s', use 0, 1 or z", CMD_ARGV
[1]);
784 return ERROR_COMMAND_SYNTAX_ERROR
;
787 return mpsse_flush(mpsse_ctx
);
790 COMMAND_HANDLER(ftdi_handle_vid_pid_command
)
792 if (CMD_ARGC
> MAX_USB_IDS
* 2) {
793 LOG_WARNING("ignoring extra IDs in ftdi_vid_pid "
794 "(maximum is %d pairs)", MAX_USB_IDS
);
795 CMD_ARGC
= MAX_USB_IDS
* 2;
797 if (CMD_ARGC
< 2 || (CMD_ARGC
& 1)) {
798 LOG_WARNING("incomplete ftdi_vid_pid configuration directive");
800 return ERROR_COMMAND_SYNTAX_ERROR
;
801 /* remove the incomplete trailing id */
806 for (i
= 0; i
< CMD_ARGC
; i
+= 2) {
807 COMMAND_PARSE_NUMBER(u16
, CMD_ARGV
[i
], ftdi_vid
[i
>> 1]);
808 COMMAND_PARSE_NUMBER(u16
, CMD_ARGV
[i
+ 1], ftdi_pid
[i
>> 1]);
812 * Explicitly terminate, in case there are multiples instances of
815 ftdi_vid
[i
>> 1] = ftdi_pid
[i
>> 1] = 0;
820 static const struct command_registration ftdi_command_handlers
[] = {
822 .name
= "ftdi_device_desc",
823 .handler
= &ftdi_handle_device_desc_command
,
824 .mode
= COMMAND_CONFIG
,
825 .help
= "set the USB device description of the FTDI device",
826 .usage
= "description_string",
829 .name
= "ftdi_serial",
830 .handler
= &ftdi_handle_serial_command
,
831 .mode
= COMMAND_CONFIG
,
832 .help
= "set the serial number of the FTDI device",
833 .usage
= "serial_string",
836 .name
= "ftdi_channel",
837 .handler
= &ftdi_handle_channel_command
,
838 .mode
= COMMAND_CONFIG
,
839 .help
= "set the channel of the FTDI device that is used as JTAG",
843 .name
= "ftdi_layout_init",
844 .handler
= &ftdi_handle_layout_init_command
,
845 .mode
= COMMAND_CONFIG
,
846 .help
= "initialize the FTDI GPIO signals used "
847 "to control output-enables and reset signals",
848 .usage
= "data direction",
851 .name
= "ftdi_layout_signal",
852 .handler
= &ftdi_handle_layout_signal_command
,
854 .help
= "define a signal controlled by one or more FTDI GPIO as data "
855 "and/or output enable",
856 .usage
= "name [-data mask|-ndata mask] [-oe mask|-noe mask]",
859 .name
= "ftdi_set_signal",
860 .handler
= &ftdi_handle_set_signal_command
,
861 .mode
= COMMAND_EXEC
,
862 .help
= "control a layout-specific signal",
863 .usage
= "name (1|0|z)",
866 .name
= "ftdi_vid_pid",
867 .handler
= &ftdi_handle_vid_pid_command
,
868 .mode
= COMMAND_CONFIG
,
869 .help
= "the vendor ID and product ID of the FTDI device",
870 .usage
= "(vid pid)* ",
872 COMMAND_REGISTRATION_DONE
875 struct jtag_interface ftdi_interface
= {
877 .supported
= DEBUG_CAP_TMS_SEQ
,
878 .commands
= ftdi_command_handlers
,
879 .transports
= jtag_only
,
881 .init
= ftdi_initialize
,
884 .speed_div
= ftdi_speed_div
,
886 .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)