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
));
131 (*psig
)->name
= strdup(name
);
132 if ((*psig
)->name
== NULL
) {
139 static int ftdi_set_signal(const struct signal
*s
, char value
)
145 if (s
->data_mask
== 0 && s
->oe_mask
== 0) {
146 LOG_ERROR("interface doesn't provide signal '%s'", s
->name
);
151 data
= s
->invert_data
;
155 if (s
->data_mask
== 0) {
156 LOG_ERROR("interface can't drive '%s' high", s
->name
);
159 data
= !s
->invert_data
;
164 if (s
->oe_mask
== 0) {
165 LOG_ERROR("interface can't tri-state '%s'", s
->name
);
168 data
= s
->invert_data
;
172 assert(0 && "invalid signal level specifier");
176 output
= data
? output
| s
->data_mask
: output
& ~s
->data_mask
;
177 if (s
->oe_mask
== s
->data_mask
)
178 direction
= oe
? direction
| s
->oe_mask
: direction
& ~s
->oe_mask
;
180 output
= oe
? output
| s
->oe_mask
: output
& ~s
->oe_mask
;
182 retval
= mpsse_set_data_bits_low_byte(mpsse_ctx
, output
& 0xff, direction
& 0xff);
183 if (retval
== ERROR_OK
)
184 retval
= mpsse_set_data_bits_high_byte(mpsse_ctx
, output
>> 8, direction
>> 8);
185 if (retval
!= ERROR_OK
) {
186 LOG_ERROR("couldn't initialize FTDI GPIO");
187 return ERROR_JTAG_INIT_FAILED
;
195 * Function move_to_state
196 * moves the TAP controller from the current state to a
197 * \a goal_state through a path given by tap_get_tms_path(). State transition
198 * logging is performed by delegation to clock_tms().
200 * @param goal_state is the destination state for the move.
202 static int move_to_state(tap_state_t goal_state
)
204 tap_state_t start_state
= tap_get_state();
206 /* goal_state is 1/2 of a tuple/pair of states which allow convenient
207 lookup of the required TMS pattern to move to this state from the
211 /* do the 2 lookups */
212 int tms_bits
= tap_get_tms_path(start_state
, goal_state
);
213 int tms_count
= tap_get_tms_path_len(start_state
, goal_state
);
215 DEBUG_JTAG_IO("start=%s goal=%s", tap_state_name(start_state
), tap_state_name(goal_state
));
217 /* Track state transitions step by step */
218 for (int i
= 0; i
< tms_count
; i
++)
219 tap_set_state(tap_state_transition(tap_get_state(), (tms_bits
>> i
) & 1));
221 return mpsse_clock_tms_cs_out(mpsse_ctx
,
222 (uint8_t *)&tms_bits
,
229 static int ftdi_speed(int speed
)
232 retval
= mpsse_set_frequency(mpsse_ctx
, speed
);
235 LOG_ERROR("couldn't set FTDI TCK speed");
242 static int ftdi_speed_div(int speed
, int *khz
)
248 static int ftdi_khz(int khz
, int *jtag_speed
)
250 if (khz
== 0 && !mpsse_is_high_speed(mpsse_ctx
)) {
251 LOG_DEBUG("RCLK not supported");
255 *jtag_speed
= khz
* 1000;
259 static void ftdi_end_state(tap_state_t state
)
261 if (tap_is_state_stable(state
))
262 tap_set_end_state(state
);
264 LOG_ERROR("BUG: %s is not a stable end state", tap_state_name(state
));
269 static int ftdi_execute_runtest(struct jtag_command
*cmd
)
271 int retval
= ERROR_OK
;
275 DEBUG_JTAG_IO("runtest %i cycles, end in %s",
276 cmd
->cmd
.runtest
->num_cycles
,
277 tap_state_name(cmd
->cmd
.runtest
->end_state
));
279 if (tap_get_state() != TAP_IDLE
)
280 move_to_state(TAP_IDLE
);
282 /* TODO: Reuse ftdi_execute_stableclocks */
283 i
= cmd
->cmd
.runtest
->num_cycles
;
284 while (i
> 0 && retval
== ERROR_OK
) {
285 /* there are no state transitions in this code, so omit state tracking */
286 unsigned this_len
= i
> 7 ? 7 : i
;
287 retval
= mpsse_clock_tms_cs_out(mpsse_ctx
, &zero
, 0, this_len
, false, JTAG_MODE
);
291 ftdi_end_state(cmd
->cmd
.runtest
->end_state
);
293 if (tap_get_state() != tap_get_end_state())
294 move_to_state(tap_get_end_state());
296 DEBUG_JTAG_IO("runtest: %i, end in %s",
297 cmd
->cmd
.runtest
->num_cycles
,
298 tap_state_name(tap_get_end_state()));
302 static int ftdi_execute_statemove(struct jtag_command
*cmd
)
304 int retval
= ERROR_OK
;
306 DEBUG_JTAG_IO("statemove end in %s",
307 tap_state_name(cmd
->cmd
.statemove
->end_state
));
309 ftdi_end_state(cmd
->cmd
.statemove
->end_state
);
311 /* shortest-path move to desired end state */
312 if (tap_get_state() != tap_get_end_state() || tap_get_end_state() == TAP_RESET
)
313 move_to_state(tap_get_end_state());
319 * Clock a bunch of TMS (or SWDIO) transitions, to change the JTAG
320 * (or SWD) state machine. REVISIT: Not the best method, perhaps.
322 static int ftdi_execute_tms(struct jtag_command
*cmd
)
324 DEBUG_JTAG_IO("TMS: %d bits", cmd
->cmd
.tms
->num_bits
);
326 /* TODO: Missing tap state tracking, also missing from ft2232.c! */
327 return mpsse_clock_tms_cs_out(mpsse_ctx
,
330 cmd
->cmd
.tms
->num_bits
,
335 static int ftdi_execute_pathmove(struct jtag_command
*cmd
)
337 int retval
= ERROR_OK
;
339 tap_state_t
*path
= cmd
->cmd
.pathmove
->path
;
340 int num_states
= cmd
->cmd
.pathmove
->num_states
;
342 DEBUG_JTAG_IO("pathmove: %i states, current: %s end: %s", num_states
,
343 tap_state_name(tap_get_state()),
344 tap_state_name(path
[num_states
-1]));
347 unsigned bit_count
= 0;
348 uint8_t tms_byte
= 0;
352 /* this loop verifies that the path is legal and logs each state in the path */
353 while (num_states
-- && retval
== ERROR_OK
) {
355 /* either TMS=0 or TMS=1 must work ... */
356 if (tap_state_transition(tap_get_state(), false)
357 == path
[state_count
])
358 buf_set_u32(&tms_byte
, bit_count
++, 1, 0x0);
359 else if (tap_state_transition(tap_get_state(), true)
360 == path
[state_count
]) {
361 buf_set_u32(&tms_byte
, bit_count
++, 1, 0x1);
363 /* ... or else the caller goofed BADLY */
365 LOG_ERROR("BUG: %s -> %s isn't a valid "
366 "TAP state transition",
367 tap_state_name(tap_get_state()),
368 tap_state_name(path
[state_count
]));
372 tap_set_state(path
[state_count
]);
375 if (bit_count
== 7 || num_states
== 0) {
376 retval
= mpsse_clock_tms_cs_out(mpsse_ctx
,
385 tap_set_end_state(tap_get_state());
390 static int ftdi_execute_scan(struct jtag_command
*cmd
)
392 int retval
= ERROR_OK
;
394 DEBUG_JTAG_IO("%s type:%d", cmd
->cmd
.scan
->ir_scan
? "IRSCAN" : "DRSCAN",
395 jtag_scan_type(cmd
->cmd
.scan
));
397 /* Make sure there are no trailing fields with num_bits == 0, or the logic below will fail. */
398 while (cmd
->cmd
.scan
->num_fields
> 0
399 && cmd
->cmd
.scan
->fields
[cmd
->cmd
.scan
->num_fields
- 1].num_bits
== 0) {
400 cmd
->cmd
.scan
->num_fields
--;
401 LOG_DEBUG("discarding trailing empty field");
404 if (cmd
->cmd
.scan
->num_fields
== 0) {
405 LOG_DEBUG("empty scan, doing nothing");
409 if (cmd
->cmd
.scan
->ir_scan
) {
410 if (tap_get_state() != TAP_IRSHIFT
)
411 move_to_state(TAP_IRSHIFT
);
413 if (tap_get_state() != TAP_DRSHIFT
)
414 move_to_state(TAP_DRSHIFT
);
417 ftdi_end_state(cmd
->cmd
.scan
->end_state
);
419 struct scan_field
*field
= cmd
->cmd
.scan
->fields
;
420 unsigned scan_size
= 0;
422 for (int i
= 0; i
< cmd
->cmd
.scan
->num_fields
; i
++, field
++) {
423 scan_size
+= field
->num_bits
;
424 DEBUG_JTAG_IO("%s%s field %d/%d %d bits",
425 field
->in_value
? "in" : "",
426 field
->out_value
? "out" : "",
428 cmd
->cmd
.scan
->num_fields
,
431 if (i
== cmd
->cmd
.scan
->num_fields
- 1 && tap_get_state() != tap_get_end_state()) {
432 /* Last field, and we're leaving IRSHIFT/DRSHIFT. Clock last bit during tap
433 * movement. This last field can't have length zero, it was checked above. */
434 mpsse_clock_data(mpsse_ctx
,
441 uint8_t last_bit
= 0;
442 if (field
->out_value
)
443 bit_copy(&last_bit
, 0, field
->out_value
, field
->num_bits
- 1, 1);
444 uint8_t tms_bits
= 0x01;
445 retval
= mpsse_clock_tms_cs(mpsse_ctx
,
453 tap_set_state(tap_state_transition(tap_get_state(), 1));
454 retval
= mpsse_clock_tms_cs_out(mpsse_ctx
,
460 tap_set_state(tap_state_transition(tap_get_state(), 0));
462 mpsse_clock_data(mpsse_ctx
,
469 if (retval
!= ERROR_OK
) {
470 LOG_ERROR("failed to add field %d in scan", i
);
475 if (tap_get_state() != tap_get_end_state())
476 move_to_state(tap_get_end_state());
478 DEBUG_JTAG_IO("%s scan, %i bits, end in %s",
479 (cmd
->cmd
.scan
->ir_scan
) ? "IR" : "DR", scan_size
,
480 tap_state_name(tap_get_end_state()));
485 static int ftdi_execute_reset(struct jtag_command
*cmd
)
487 DEBUG_JTAG_IO("reset trst: %i srst %i",
488 cmd
->cmd
.reset
->trst
, cmd
->cmd
.reset
->srst
);
490 if (cmd
->cmd
.reset
->trst
== 1
491 || (cmd
->cmd
.reset
->srst
492 && (jtag_get_reset_config() & RESET_SRST_PULLS_TRST
)))
493 tap_set_state(TAP_RESET
);
495 struct signal
*trst
= find_signal_by_name("nTRST");
496 if (trst
&& cmd
->cmd
.reset
->trst
== 1) {
497 ftdi_set_signal(trst
, '0');
498 } else if (trst
&& cmd
->cmd
.reset
->trst
== 0) {
499 if (jtag_get_reset_config() & RESET_TRST_OPEN_DRAIN
)
500 ftdi_set_signal(trst
, 'z');
502 ftdi_set_signal(trst
, '1');
505 struct signal
*srst
= find_signal_by_name("nSRST");
506 if (srst
&& cmd
->cmd
.reset
->srst
== 1) {
507 ftdi_set_signal(srst
, '0');
508 } else if (srst
&& cmd
->cmd
.reset
->srst
== 0) {
509 if (jtag_get_reset_config() & RESET_SRST_PUSH_PULL
)
510 ftdi_set_signal(srst
, '1');
512 ftdi_set_signal(srst
, 'z');
515 DEBUG_JTAG_IO("trst: %i, srst: %i",
516 cmd
->cmd
.reset
->trst
, cmd
->cmd
.reset
->srst
);
520 static int ftdi_execute_sleep(struct jtag_command
*cmd
)
522 int retval
= ERROR_OK
;
524 DEBUG_JTAG_IO("sleep %" PRIi32
, cmd
->cmd
.sleep
->us
);
526 retval
= mpsse_flush(mpsse_ctx
);
527 jtag_sleep(cmd
->cmd
.sleep
->us
);
528 DEBUG_JTAG_IO("sleep %" PRIi32
" usec while in %s",
530 tap_state_name(tap_get_state()));
534 static int ftdi_execute_stableclocks(struct jtag_command
*cmd
)
536 int retval
= ERROR_OK
;
538 /* this is only allowed while in a stable state. A check for a stable
539 * state was done in jtag_add_clocks()
541 int num_cycles
= cmd
->cmd
.stableclocks
->num_cycles
;
543 /* 7 bits of either ones or zeros. */
544 uint8_t tms
= tap_get_state() == TAP_RESET
? 0x7f : 0x00;
546 /* TODO: Use mpsse_clock_data with in=out=0 for this, if TMS can be set to
547 * the correct level and remain there during the scan */
548 while (num_cycles
> 0 && retval
== ERROR_OK
) {
549 /* there are no state transitions in this code, so omit state tracking */
550 unsigned this_len
= num_cycles
> 7 ? 7 : num_cycles
;
551 retval
= mpsse_clock_tms_cs_out(mpsse_ctx
, &tms
, 0, this_len
, false, JTAG_MODE
);
552 num_cycles
-= this_len
;
555 DEBUG_JTAG_IO("clocks %i while in %s",
556 cmd
->cmd
.stableclocks
->num_cycles
,
557 tap_state_name(tap_get_state()));
561 static int ftdi_execute_command(struct jtag_command
*cmd
)
567 retval
= ftdi_execute_reset(cmd
);
570 retval
= ftdi_execute_runtest(cmd
);
573 retval
= ftdi_execute_statemove(cmd
);
576 retval
= ftdi_execute_pathmove(cmd
);
579 retval
= ftdi_execute_scan(cmd
);
582 retval
= ftdi_execute_sleep(cmd
);
584 case JTAG_STABLECLOCKS
:
585 retval
= ftdi_execute_stableclocks(cmd
);
588 retval
= ftdi_execute_tms(cmd
);
591 LOG_ERROR("BUG: unknown JTAG command type encountered: %d", cmd
->type
);
592 retval
= ERROR_JTAG_QUEUE_FAILED
;
598 static int ftdi_execute_queue(void)
600 int retval
= ERROR_OK
;
602 /* blink, if the current layout has that feature */
603 struct signal
*led
= find_signal_by_name("LED");
605 ftdi_set_signal(led
, '1');
607 for (struct jtag_command
*cmd
= jtag_command_queue
; cmd
; cmd
= cmd
->next
) {
608 /* fill the write buffer with the desired command */
609 if (ftdi_execute_command(cmd
) != ERROR_OK
)
610 retval
= ERROR_JTAG_QUEUE_FAILED
;
614 ftdi_set_signal(led
, '0');
616 retval
= mpsse_flush(mpsse_ctx
);
617 if (retval
!= ERROR_OK
)
618 LOG_ERROR("error while flushing MPSSE queue: %d", retval
);
623 static int ftdi_initialize(void)
627 if (tap_get_tms_path_len(TAP_IRPAUSE
, TAP_IRPAUSE
) == 7)
628 LOG_DEBUG("ftdi interface using 7 step jtag state transitions");
630 LOG_DEBUG("ftdi interface using shortest path jtag state transitions");
632 for (int i
= 0; ftdi_vid
[i
] || ftdi_pid
[i
]; i
++) {
633 mpsse_ctx
= mpsse_open(&ftdi_vid
[i
], &ftdi_pid
[i
], ftdi_device_desc
,
634 ftdi_serial
, ftdi_channel
);
640 return ERROR_JTAG_INIT_FAILED
;
642 retval
= mpsse_set_data_bits_low_byte(mpsse_ctx
, output
& 0xff, direction
& 0xff);
643 if (retval
== ERROR_OK
)
644 retval
= mpsse_set_data_bits_high_byte(mpsse_ctx
, output
>> 8, direction
>> 8);
645 if (retval
!= ERROR_OK
) {
646 LOG_ERROR("couldn't initialize FTDI with configured layout");
647 return ERROR_JTAG_INIT_FAILED
;
650 retval
= mpsse_loopback_config(mpsse_ctx
, false);
651 if (retval
!= ERROR_OK
) {
652 LOG_ERROR("couldn't write to FTDI to disable loopback");
653 return ERROR_JTAG_INIT_FAILED
;
656 return mpsse_flush(mpsse_ctx
);
659 static int ftdi_quit(void)
661 mpsse_close(mpsse_ctx
);
666 COMMAND_HANDLER(ftdi_handle_device_desc_command
)
669 if (ftdi_device_desc
)
670 free(ftdi_device_desc
);
671 ftdi_device_desc
= strdup(CMD_ARGV
[0]);
673 LOG_ERROR("expected exactly one argument to ftdi_device_desc <description>");
679 COMMAND_HANDLER(ftdi_handle_serial_command
)
684 ftdi_serial
= strdup(CMD_ARGV
[0]);
686 return ERROR_COMMAND_SYNTAX_ERROR
;
692 COMMAND_HANDLER(ftdi_handle_channel_command
)
695 COMMAND_PARSE_NUMBER(u8
, CMD_ARGV
[0], ftdi_channel
);
697 return ERROR_COMMAND_SYNTAX_ERROR
;
702 COMMAND_HANDLER(ftdi_handle_layout_init_command
)
705 return ERROR_COMMAND_SYNTAX_ERROR
;
707 COMMAND_PARSE_NUMBER(u16
, CMD_ARGV
[0], output
);
708 COMMAND_PARSE_NUMBER(u16
, CMD_ARGV
[1], direction
);
713 COMMAND_HANDLER(ftdi_handle_layout_signal_command
)
716 return ERROR_COMMAND_SYNTAX_ERROR
;
718 bool invert_data
= false;
719 uint16_t data_mask
= 0;
720 bool invert_oe
= false;
721 uint16_t oe_mask
= 0;
722 for (unsigned i
= 1; i
< CMD_ARGC
; i
+= 2) {
723 if (strcmp("-data", CMD_ARGV
[i
]) == 0) {
725 COMMAND_PARSE_NUMBER(u16
, CMD_ARGV
[i
+ 1], data_mask
);
726 } else if (strcmp("-ndata", CMD_ARGV
[i
]) == 0) {
728 COMMAND_PARSE_NUMBER(u16
, CMD_ARGV
[i
+ 1], data_mask
);
729 } else if (strcmp("-oe", CMD_ARGV
[i
]) == 0) {
731 COMMAND_PARSE_NUMBER(u16
, CMD_ARGV
[i
+ 1], oe_mask
);
732 } else if (strcmp("-noe", CMD_ARGV
[i
]) == 0) {
734 COMMAND_PARSE_NUMBER(u16
, CMD_ARGV
[i
+ 1], oe_mask
);
736 LOG_ERROR("unknown option '%s'", CMD_ARGV
[i
]);
737 return ERROR_COMMAND_SYNTAX_ERROR
;
742 sig
= find_signal_by_name(CMD_ARGV
[0]);
744 sig
= create_signal(CMD_ARGV
[0]);
746 LOG_ERROR("failed to create signal %s", CMD_ARGV
[0]);
750 sig
->invert_data
= invert_data
;
751 sig
->data_mask
= data_mask
;
752 sig
->invert_oe
= invert_oe
;
753 sig
->oe_mask
= oe_mask
;
758 COMMAND_HANDLER(ftdi_handle_set_signal_command
)
761 return ERROR_COMMAND_SYNTAX_ERROR
;
764 sig
= find_signal_by_name(CMD_ARGV
[0]);
766 LOG_ERROR("interface configuration doesn't define signal '%s'", CMD_ARGV
[0]);
770 switch (*CMD_ARGV
[1]) {
775 /* single character level specifier only */
776 if (CMD_ARGV
[1][1] == '\0') {
777 ftdi_set_signal(sig
, *CMD_ARGV
[1]);
781 LOG_ERROR("unknown signal level '%s', use 0, 1 or z", CMD_ARGV
[1]);
782 return ERROR_COMMAND_SYNTAX_ERROR
;
785 return mpsse_flush(mpsse_ctx
);
788 COMMAND_HANDLER(ftdi_handle_vid_pid_command
)
790 if (CMD_ARGC
> MAX_USB_IDS
* 2) {
791 LOG_WARNING("ignoring extra IDs in ftdi_vid_pid "
792 "(maximum is %d pairs)", MAX_USB_IDS
);
793 CMD_ARGC
= MAX_USB_IDS
* 2;
795 if (CMD_ARGC
< 2 || (CMD_ARGC
& 1)) {
796 LOG_WARNING("incomplete ftdi_vid_pid configuration directive");
798 return ERROR_COMMAND_SYNTAX_ERROR
;
799 /* remove the incomplete trailing id */
804 for (i
= 0; i
< CMD_ARGC
; i
+= 2) {
805 COMMAND_PARSE_NUMBER(u16
, CMD_ARGV
[i
], ftdi_vid
[i
>> 1]);
806 COMMAND_PARSE_NUMBER(u16
, CMD_ARGV
[i
+ 1], ftdi_pid
[i
>> 1]);
810 * Explicitly terminate, in case there are multiples instances of
813 ftdi_vid
[i
>> 1] = ftdi_pid
[i
>> 1] = 0;
818 static const struct command_registration ftdi_command_handlers
[] = {
820 .name
= "ftdi_device_desc",
821 .handler
= &ftdi_handle_device_desc_command
,
822 .mode
= COMMAND_CONFIG
,
823 .help
= "set the USB device description of the FTDI device",
824 .usage
= "description_string",
827 .name
= "ftdi_serial",
828 .handler
= &ftdi_handle_serial_command
,
829 .mode
= COMMAND_CONFIG
,
830 .help
= "set the serial number of the FTDI device",
831 .usage
= "serial_string",
834 .name
= "ftdi_channel",
835 .handler
= &ftdi_handle_channel_command
,
836 .mode
= COMMAND_CONFIG
,
837 .help
= "set the channel of the FTDI device that is used as JTAG",
841 .name
= "ftdi_layout_init",
842 .handler
= &ftdi_handle_layout_init_command
,
843 .mode
= COMMAND_CONFIG
,
844 .help
= "initialize the FTDI GPIO signals used "
845 "to control output-enables and reset signals",
846 .usage
= "data direction",
849 .name
= "ftdi_layout_signal",
850 .handler
= &ftdi_handle_layout_signal_command
,
852 .help
= "define a signal controlled by one or more FTDI GPIO as data "
853 "and/or output enable",
854 .usage
= "name [-data mask|-ndata mask] [-oe mask|-noe mask]",
857 .name
= "ftdi_set_signal",
858 .handler
= &ftdi_handle_set_signal_command
,
859 .mode
= COMMAND_EXEC
,
860 .help
= "control a layout-specific signal",
861 .usage
= "name (1|0|z)",
864 .name
= "ftdi_vid_pid",
865 .handler
= &ftdi_handle_vid_pid_command
,
866 .mode
= COMMAND_CONFIG
,
867 .help
= "the vendor ID and product ID of the FTDI device",
868 .usage
= "(vid pid)* ",
870 COMMAND_REGISTRATION_DONE
873 struct jtag_interface ftdi_interface
= {
875 .supported
= DEBUG_CAP_TMS_SEQ
,
876 .commands
= ftdi_command_handlers
,
877 .transports
= jtag_only
,
879 .init
= ftdi_initialize
,
882 .speed_div
= ftdi_speed_div
,
884 .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)