1 // SPDX-License-Identifier: GPL-2.0-or-later
3 /**************************************************************************
4 * Copyright (C) 2012 by Andreas Fritiofson *
5 * andreas.fritiofson@gmail.com *
6 ***************************************************************************/
10 * JTAG adapters based on the FT2232 full and high speed USB parts are
11 * popular low cost JTAG debug solutions. Many FT2232 based JTAG adapters
12 * are discrete, but development boards may integrate them as alternatives
13 * to more capable (and expensive) third party JTAG pods.
15 * JTAG uses only one of the two communications channels ("MPSSE engines")
16 * on these devices. Adapters based on FT4232 parts have four ports/channels
17 * (A/B/C/D), instead of just two (A/B).
19 * Especially on development boards integrating one of these chips (as
20 * opposed to discrete pods/dongles), the additional channels can be used
21 * for a variety of purposes, but OpenOCD only uses one channel at a time.
23 * - As a USB-to-serial adapter for the target's console UART ...
24 * which may be able to support ROM boot loaders that load initial
25 * firmware images to flash (or SRAM).
27 * - On systems which support ARM's SWD in addition to JTAG, or instead
28 * of it, that second port can be used for reading SWV/SWO trace data.
30 * - Additional JTAG links, e.g. to a CPLD or * FPGA.
32 * FT2232 based JTAG adapters are "dumb" not "smart", because most JTAG
33 * request/response interactions involve round trips over the USB link.
34 * A "smart" JTAG adapter has intelligence close to the scan chain, so it
35 * can for example poll quickly for a status change (usually taking on the
36 * order of microseconds not milliseconds) before beginning a queued
37 * transaction which require the previous one to have completed.
39 * There are dozens of adapters of this type, differing in details which
40 * this driver needs to understand. Those "layout" details are required
41 * as part of FT2232 driver configuration.
43 * This code uses information contained in the MPSSE specification which was
45 * https://www.ftdichip.com/Support/Documents/AppNotes/AN2232C-01_MPSSE_Cmnd.pdf
46 * Hereafter this is called the "MPSSE Spec".
48 * The datasheet for the ftdichip.com's FT2232H part is here:
49 * https://www.ftdichip.com/Support/Documents/DataSheets/ICs/DS_FT2232H.pdf
51 * Also note the issue with code 0x4b (clock data to TMS) noted in
52 * http://developer.intra2net.com/mailarchive/html/libftdi/2009/msg00292.html
53 * which can affect longer JTAG state paths.
60 /* project specific includes */
61 #include <jtag/adapter.h>
62 #include <jtag/interface.h>
64 #include <transport/transport.h>
65 #include <helper/time_support.h>
66 #include <helper/log.h>
74 /* FTDI access library includes */
77 #define JTAG_MODE (LSB_FIRST | POS_EDGE_IN | NEG_EDGE_OUT)
78 #define JTAG_MODE_ALT (LSB_FIRST | NEG_EDGE_IN | NEG_EDGE_OUT)
79 #define SWD_MODE (LSB_FIRST | POS_EDGE_IN | NEG_EDGE_OUT)
81 static char *ftdi_device_desc
;
82 static uint8_t ftdi_channel
;
83 static uint8_t ftdi_jtag_mode
= JTAG_MODE
;
88 /* vid = pid = 0 marks the end of the list */
89 static uint16_t ftdi_vid
[MAX_USB_IDS
+ 1] = { 0 };
90 static uint16_t ftdi_pid
[MAX_USB_IDS
+ 1] = { 0 };
92 static struct mpsse_ctx
*mpsse_ctx
;
105 static struct signal
*signals
;
107 /* FIXME: Where to store per-instance data? We need an SWD context. */
108 static struct swd_cmd_queue_entry
{
111 uint8_t trn_ack_data_parity_trn
[DIV_ROUND_UP(4 + 3 + 32 + 1 + 4, 8)];
113 static size_t swd_cmd_queue_length
;
114 static size_t swd_cmd_queue_alloced
;
115 static int queued_retval
;
118 static uint16_t output
;
119 static uint16_t direction
;
120 static uint16_t jtag_output_init
;
121 static uint16_t jtag_direction_init
;
123 static int ftdi_swd_switch_seq(enum swd_special_seq seq
);
125 static struct signal
*find_signal_by_name(const char *name
)
127 for (struct signal
*sig
= signals
; sig
; sig
= sig
->next
) {
128 if (strcmp(name
, sig
->name
) == 0)
134 static struct signal
*create_signal(const char *name
)
136 struct signal
**psig
= &signals
;
138 psig
= &(*psig
)->next
;
140 *psig
= calloc(1, sizeof(**psig
));
144 (*psig
)->name
= strdup(name
);
145 if (!(*psig
)->name
) {
152 static int ftdi_set_signal(const struct signal
*s
, char value
)
157 if (s
->data_mask
== 0 && s
->oe_mask
== 0) {
158 LOG_ERROR("interface doesn't provide signal '%s'", s
->name
);
163 data
= s
->invert_data
;
167 if (s
->data_mask
== 0) {
168 LOG_ERROR("interface can't drive '%s' high", s
->name
);
171 data
= !s
->invert_data
;
176 if (s
->oe_mask
== 0) {
177 LOG_ERROR("interface can't tri-state '%s'", s
->name
);
180 data
= s
->invert_data
;
184 assert(0 && "invalid signal level specifier");
188 uint16_t old_output
= output
;
189 uint16_t old_direction
= direction
;
191 output
= data
? output
| s
->data_mask
: output
& ~s
->data_mask
;
192 if (s
->oe_mask
== s
->data_mask
)
193 direction
= oe
? direction
| s
->oe_mask
: direction
& ~s
->oe_mask
;
195 output
= oe
? output
| s
->oe_mask
: output
& ~s
->oe_mask
;
197 if ((output
& 0xff) != (old_output
& 0xff) || (direction
& 0xff) != (old_direction
& 0xff))
198 mpsse_set_data_bits_low_byte(mpsse_ctx
, output
& 0xff, direction
& 0xff);
199 if ((output
>> 8 != old_output
>> 8) || (direction
>> 8 != old_direction
>> 8))
200 mpsse_set_data_bits_high_byte(mpsse_ctx
, output
>> 8, direction
>> 8);
205 static int ftdi_get_signal(const struct signal
*s
, uint16_t *value_out
)
207 uint8_t data_low
= 0;
208 uint8_t data_high
= 0;
210 if (s
->input_mask
== 0) {
211 LOG_ERROR("interface doesn't provide signal '%s'", s
->name
);
215 if (s
->input_mask
& 0xff)
216 mpsse_read_data_bits_low_byte(mpsse_ctx
, &data_low
);
217 if (s
->input_mask
>> 8)
218 mpsse_read_data_bits_high_byte(mpsse_ctx
, &data_high
);
220 mpsse_flush(mpsse_ctx
);
222 *value_out
= (((uint16_t)data_high
) << 8) | data_low
;
225 *value_out
= ~(*value_out
);
227 *value_out
&= s
->input_mask
;
233 * Function move_to_state
234 * moves the TAP controller from the current state to a
235 * \a goal_state through a path given by tap_get_tms_path(). State transition
236 * logging is performed by delegation to clock_tms().
238 * @param goal_state is the destination state for the move.
240 static void move_to_state(tap_state_t goal_state
)
242 tap_state_t start_state
= tap_get_state();
244 /* goal_state is 1/2 of a tuple/pair of states which allow convenient
245 lookup of the required TMS pattern to move to this state from the
249 /* do the 2 lookups */
250 uint8_t tms_bits
= tap_get_tms_path(start_state
, goal_state
);
251 int tms_count
= tap_get_tms_path_len(start_state
, goal_state
);
252 assert(tms_count
<= 8);
254 LOG_DEBUG_IO("start=%s goal=%s", tap_state_name(start_state
), tap_state_name(goal_state
));
256 /* Track state transitions step by step */
257 for (int i
= 0; i
< tms_count
; i
++)
258 tap_set_state(tap_state_transition(tap_get_state(), (tms_bits
>> i
) & 1));
260 mpsse_clock_tms_cs_out(mpsse_ctx
,
268 static int ftdi_speed(int speed
)
271 retval
= mpsse_set_frequency(mpsse_ctx
, speed
);
274 LOG_ERROR("couldn't set FTDI TCK speed");
278 if (!swd_mode
&& speed
>= 10000000 && ftdi_jtag_mode
!= JTAG_MODE_ALT
)
279 LOG_INFO("ftdi: if you experience problems at higher adapter clocks, try "
280 "the command \"ftdi tdo_sample_edge falling\"");
284 static int ftdi_speed_div(int speed
, int *khz
)
290 static int ftdi_khz(int khz
, int *jtag_speed
)
292 if (khz
== 0 && !mpsse_is_high_speed(mpsse_ctx
)) {
293 LOG_DEBUG("RCLK not supported");
297 *jtag_speed
= khz
* 1000;
301 static void ftdi_end_state(tap_state_t state
)
303 if (tap_is_state_stable(state
))
304 tap_set_end_state(state
);
306 LOG_ERROR("BUG: %s is not a stable end state", tap_state_name(state
));
311 static void ftdi_execute_runtest(struct jtag_command
*cmd
)
316 LOG_DEBUG_IO("runtest %i cycles, end in %s",
317 cmd
->cmd
.runtest
->num_cycles
,
318 tap_state_name(cmd
->cmd
.runtest
->end_state
));
320 if (tap_get_state() != TAP_IDLE
)
321 move_to_state(TAP_IDLE
);
323 /* TODO: Reuse ftdi_execute_stableclocks */
324 i
= cmd
->cmd
.runtest
->num_cycles
;
326 /* there are no state transitions in this code, so omit state tracking */
327 unsigned this_len
= i
> 7 ? 7 : i
;
328 mpsse_clock_tms_cs_out(mpsse_ctx
, &zero
, 0, this_len
, false, ftdi_jtag_mode
);
332 ftdi_end_state(cmd
->cmd
.runtest
->end_state
);
334 if (tap_get_state() != tap_get_end_state())
335 move_to_state(tap_get_end_state());
337 LOG_DEBUG_IO("runtest: %i, end in %s",
338 cmd
->cmd
.runtest
->num_cycles
,
339 tap_state_name(tap_get_end_state()));
342 static void ftdi_execute_statemove(struct jtag_command
*cmd
)
344 LOG_DEBUG_IO("statemove end in %s",
345 tap_state_name(cmd
->cmd
.statemove
->end_state
));
347 ftdi_end_state(cmd
->cmd
.statemove
->end_state
);
349 /* shortest-path move to desired end state */
350 if (tap_get_state() != tap_get_end_state() || tap_get_end_state() == TAP_RESET
)
351 move_to_state(tap_get_end_state());
355 * Clock a bunch of TMS (or SWDIO) transitions, to change the JTAG
356 * (or SWD) state machine. REVISIT: Not the best method, perhaps.
358 static void ftdi_execute_tms(struct jtag_command
*cmd
)
360 LOG_DEBUG_IO("TMS: %d bits", cmd
->cmd
.tms
->num_bits
);
362 /* TODO: Missing tap state tracking, also missing from ft2232.c! */
363 mpsse_clock_tms_cs_out(mpsse_ctx
,
366 cmd
->cmd
.tms
->num_bits
,
371 static void ftdi_execute_pathmove(struct jtag_command
*cmd
)
373 tap_state_t
*path
= cmd
->cmd
.pathmove
->path
;
374 int num_states
= cmd
->cmd
.pathmove
->num_states
;
376 LOG_DEBUG_IO("pathmove: %i states, current: %s end: %s", num_states
,
377 tap_state_name(tap_get_state()),
378 tap_state_name(path
[num_states
-1]));
381 unsigned bit_count
= 0;
382 uint8_t tms_byte
= 0;
386 /* this loop verifies that the path is legal and logs each state in the path */
387 while (num_states
--) {
389 /* either TMS=0 or TMS=1 must work ... */
390 if (tap_state_transition(tap_get_state(), false)
391 == path
[state_count
])
392 buf_set_u32(&tms_byte
, bit_count
++, 1, 0x0);
393 else if (tap_state_transition(tap_get_state(), true)
394 == path
[state_count
]) {
395 buf_set_u32(&tms_byte
, bit_count
++, 1, 0x1);
397 /* ... or else the caller goofed BADLY */
399 LOG_ERROR("BUG: %s -> %s isn't a valid "
400 "TAP state transition",
401 tap_state_name(tap_get_state()),
402 tap_state_name(path
[state_count
]));
406 tap_set_state(path
[state_count
]);
409 if (bit_count
== 7 || num_states
== 0) {
410 mpsse_clock_tms_cs_out(mpsse_ctx
,
419 tap_set_end_state(tap_get_state());
422 static void ftdi_execute_scan(struct jtag_command
*cmd
)
424 LOG_DEBUG_IO("%s type:%d", cmd
->cmd
.scan
->ir_scan
? "IRSCAN" : "DRSCAN",
425 jtag_scan_type(cmd
->cmd
.scan
));
427 /* Make sure there are no trailing fields with num_bits == 0, or the logic below will fail. */
428 while (cmd
->cmd
.scan
->num_fields
> 0
429 && cmd
->cmd
.scan
->fields
[cmd
->cmd
.scan
->num_fields
- 1].num_bits
== 0) {
430 cmd
->cmd
.scan
->num_fields
--;
431 LOG_DEBUG_IO("discarding trailing empty field");
434 if (cmd
->cmd
.scan
->num_fields
== 0) {
435 LOG_DEBUG_IO("empty scan, doing nothing");
439 if (cmd
->cmd
.scan
->ir_scan
) {
440 if (tap_get_state() != TAP_IRSHIFT
)
441 move_to_state(TAP_IRSHIFT
);
443 if (tap_get_state() != TAP_DRSHIFT
)
444 move_to_state(TAP_DRSHIFT
);
447 ftdi_end_state(cmd
->cmd
.scan
->end_state
);
449 struct scan_field
*field
= cmd
->cmd
.scan
->fields
;
450 unsigned scan_size
= 0;
452 for (int i
= 0; i
< cmd
->cmd
.scan
->num_fields
; i
++, field
++) {
453 scan_size
+= field
->num_bits
;
454 LOG_DEBUG_IO("%s%s field %d/%d %d bits",
455 field
->in_value
? "in" : "",
456 field
->out_value
? "out" : "",
458 cmd
->cmd
.scan
->num_fields
,
461 if (i
== cmd
->cmd
.scan
->num_fields
- 1 && tap_get_state() != tap_get_end_state()) {
462 /* Last field, and we're leaving IRSHIFT/DRSHIFT. Clock last bit during tap
463 * movement. This last field can't have length zero, it was checked above. */
464 mpsse_clock_data(mpsse_ctx
,
471 uint8_t last_bit
= 0;
472 if (field
->out_value
)
473 bit_copy(&last_bit
, 0, field
->out_value
, field
->num_bits
- 1, 1);
475 /* If endstate is TAP_IDLE, clock out 1-1-0 (->EXIT1 ->UPDATE ->IDLE)
476 * Otherwise, clock out 1-0 (->EXIT1 ->PAUSE)
478 uint8_t tms_bits
= 0x03;
479 mpsse_clock_tms_cs(mpsse_ctx
,
487 tap_set_state(tap_state_transition(tap_get_state(), 1));
488 if (tap_get_end_state() == TAP_IDLE
) {
489 mpsse_clock_tms_cs_out(mpsse_ctx
,
495 tap_set_state(tap_state_transition(tap_get_state(), 1));
496 tap_set_state(tap_state_transition(tap_get_state(), 0));
498 mpsse_clock_tms_cs_out(mpsse_ctx
,
504 tap_set_state(tap_state_transition(tap_get_state(), 0));
507 mpsse_clock_data(mpsse_ctx
,
516 if (tap_get_state() != tap_get_end_state())
517 move_to_state(tap_get_end_state());
519 LOG_DEBUG_IO("%s scan, %i bits, end in %s",
520 (cmd
->cmd
.scan
->ir_scan
) ? "IR" : "DR", scan_size
,
521 tap_state_name(tap_get_end_state()));
524 static int ftdi_reset(int trst
, int srst
)
526 struct signal
*sig_ntrst
= find_signal_by_name("nTRST");
527 struct signal
*sig_nsrst
= find_signal_by_name("nSRST");
529 LOG_DEBUG_IO("reset trst: %i srst %i", trst
, srst
);
534 ftdi_set_signal(sig_ntrst
, '0');
536 LOG_ERROR("Can't assert TRST: nTRST signal is not defined");
537 } else if (sig_ntrst
&& jtag_get_reset_config() & RESET_HAS_TRST
&&
539 if (jtag_get_reset_config() & RESET_TRST_OPEN_DRAIN
)
540 ftdi_set_signal(sig_ntrst
, 'z');
542 ftdi_set_signal(sig_ntrst
, '1');
548 ftdi_set_signal(sig_nsrst
, '0');
550 LOG_ERROR("Can't assert SRST: nSRST signal is not defined");
551 } else if (sig_nsrst
&& jtag_get_reset_config() & RESET_HAS_SRST
&&
553 if (jtag_get_reset_config() & RESET_SRST_PUSH_PULL
)
554 ftdi_set_signal(sig_nsrst
, '1');
556 ftdi_set_signal(sig_nsrst
, 'z');
559 return mpsse_flush(mpsse_ctx
);
562 static void ftdi_execute_sleep(struct jtag_command
*cmd
)
564 LOG_DEBUG_IO("sleep %" PRIu32
, cmd
->cmd
.sleep
->us
);
566 mpsse_flush(mpsse_ctx
);
567 jtag_sleep(cmd
->cmd
.sleep
->us
);
568 LOG_DEBUG_IO("sleep %" PRIu32
" usec while in %s",
570 tap_state_name(tap_get_state()));
573 static void ftdi_execute_stableclocks(struct jtag_command
*cmd
)
575 /* this is only allowed while in a stable state. A check for a stable
576 * state was done in jtag_add_clocks()
578 int num_cycles
= cmd
->cmd
.stableclocks
->num_cycles
;
580 /* 7 bits of either ones or zeros. */
581 uint8_t tms
= tap_get_state() == TAP_RESET
? 0x7f : 0x00;
583 /* TODO: Use mpsse_clock_data with in=out=0 for this, if TMS can be set to
584 * the correct level and remain there during the scan */
585 while (num_cycles
> 0) {
586 /* there are no state transitions in this code, so omit state tracking */
587 unsigned this_len
= num_cycles
> 7 ? 7 : num_cycles
;
588 mpsse_clock_tms_cs_out(mpsse_ctx
, &tms
, 0, this_len
, false, ftdi_jtag_mode
);
589 num_cycles
-= this_len
;
592 LOG_DEBUG_IO("clocks %i while in %s",
593 cmd
->cmd
.stableclocks
->num_cycles
,
594 tap_state_name(tap_get_state()));
597 static void ftdi_execute_command(struct jtag_command
*cmd
)
601 ftdi_execute_runtest(cmd
);
604 ftdi_execute_statemove(cmd
);
607 ftdi_execute_pathmove(cmd
);
610 ftdi_execute_scan(cmd
);
613 ftdi_execute_sleep(cmd
);
615 case JTAG_STABLECLOCKS
:
616 ftdi_execute_stableclocks(cmd
);
619 ftdi_execute_tms(cmd
);
622 LOG_ERROR("BUG: unknown JTAG command type encountered: %d", cmd
->type
);
627 static int ftdi_execute_queue(void)
629 /* blink, if the current layout has that feature */
630 struct signal
*led
= find_signal_by_name("LED");
632 ftdi_set_signal(led
, '1');
634 for (struct jtag_command
*cmd
= jtag_command_queue
; cmd
; cmd
= cmd
->next
) {
635 /* fill the write buffer with the desired command */
636 ftdi_execute_command(cmd
);
640 ftdi_set_signal(led
, '0');
642 int retval
= mpsse_flush(mpsse_ctx
);
643 if (retval
!= ERROR_OK
)
644 LOG_ERROR("error while flushing MPSSE queue: %d", retval
);
649 static int ftdi_initialize(void)
651 if (tap_get_tms_path_len(TAP_IRPAUSE
, TAP_IRPAUSE
) == 7)
652 LOG_DEBUG("ftdi interface using 7 step jtag state transitions");
654 LOG_DEBUG("ftdi interface using shortest path jtag state transitions");
656 if (!ftdi_vid
[0] && !ftdi_pid
[0]) {
657 LOG_ERROR("Please specify ftdi vid_pid");
658 return ERROR_JTAG_INIT_FAILED
;
661 for (int i
= 0; ftdi_vid
[i
] || ftdi_pid
[i
]; i
++) {
662 mpsse_ctx
= mpsse_open(&ftdi_vid
[i
], &ftdi_pid
[i
], ftdi_device_desc
,
663 adapter_get_required_serial(), adapter_usb_get_location(), ftdi_channel
);
669 return ERROR_JTAG_INIT_FAILED
;
671 output
= jtag_output_init
;
672 direction
= jtag_direction_init
;
675 struct signal
*sig
= find_signal_by_name("SWD_EN");
677 LOG_ERROR("SWD mode is active but SWD_EN signal is not defined");
678 return ERROR_JTAG_INIT_FAILED
;
680 /* A dummy SWD_EN would have zero mask */
682 ftdi_set_signal(sig
, '1');
685 mpsse_set_data_bits_low_byte(mpsse_ctx
, output
& 0xff, direction
& 0xff);
686 mpsse_set_data_bits_high_byte(mpsse_ctx
, output
>> 8, direction
>> 8);
688 mpsse_loopback_config(mpsse_ctx
, false);
690 freq
= mpsse_set_frequency(mpsse_ctx
, adapter_get_speed_khz() * 1000);
692 return mpsse_flush(mpsse_ctx
);
695 static int ftdi_quit(void)
697 mpsse_close(mpsse_ctx
);
699 struct signal
*sig
= signals
;
701 struct signal
*next
= sig
->next
;
702 free((void *)sig
->name
);
707 free(ftdi_device_desc
);
714 COMMAND_HANDLER(ftdi_handle_device_desc_command
)
717 free(ftdi_device_desc
);
718 ftdi_device_desc
= strdup(CMD_ARGV
[0]);
720 LOG_ERROR("expected exactly one argument to ftdi device_desc <description>");
726 COMMAND_HANDLER(ftdi_handle_channel_command
)
729 COMMAND_PARSE_NUMBER(u8
, CMD_ARGV
[0], ftdi_channel
);
731 return ERROR_COMMAND_SYNTAX_ERROR
;
736 COMMAND_HANDLER(ftdi_handle_layout_init_command
)
739 return ERROR_COMMAND_SYNTAX_ERROR
;
741 COMMAND_PARSE_NUMBER(u16
, CMD_ARGV
[0], jtag_output_init
);
742 COMMAND_PARSE_NUMBER(u16
, CMD_ARGV
[1], jtag_direction_init
);
747 COMMAND_HANDLER(ftdi_handle_layout_signal_command
)
750 return ERROR_COMMAND_SYNTAX_ERROR
;
752 bool invert_data
= false;
753 uint16_t data_mask
= 0;
754 bool invert_input
= false;
755 uint16_t input_mask
= 0;
756 bool invert_oe
= false;
757 uint16_t oe_mask
= 0;
758 for (unsigned i
= 1; i
< CMD_ARGC
; i
+= 2) {
759 if (strcmp("-data", CMD_ARGV
[i
]) == 0) {
761 COMMAND_PARSE_NUMBER(u16
, CMD_ARGV
[i
+ 1], data_mask
);
762 } else if (strcmp("-ndata", CMD_ARGV
[i
]) == 0) {
764 COMMAND_PARSE_NUMBER(u16
, CMD_ARGV
[i
+ 1], data_mask
);
765 } else if (strcmp("-input", CMD_ARGV
[i
]) == 0) {
766 invert_input
= false;
767 COMMAND_PARSE_NUMBER(u16
, CMD_ARGV
[i
+ 1], input_mask
);
768 } else if (strcmp("-ninput", CMD_ARGV
[i
]) == 0) {
770 COMMAND_PARSE_NUMBER(u16
, CMD_ARGV
[i
+ 1], input_mask
);
771 } else if (strcmp("-oe", CMD_ARGV
[i
]) == 0) {
773 COMMAND_PARSE_NUMBER(u16
, CMD_ARGV
[i
+ 1], oe_mask
);
774 } else if (strcmp("-noe", CMD_ARGV
[i
]) == 0) {
776 COMMAND_PARSE_NUMBER(u16
, CMD_ARGV
[i
+ 1], oe_mask
);
777 } else if (!strcmp("-alias", CMD_ARGV
[i
]) ||
778 !strcmp("-nalias", CMD_ARGV
[i
])) {
779 if (!strcmp("-nalias", CMD_ARGV
[i
])) {
783 struct signal
*sig
= find_signal_by_name(CMD_ARGV
[i
+ 1]);
785 LOG_ERROR("signal %s is not defined", CMD_ARGV
[i
+ 1]);
788 data_mask
= sig
->data_mask
;
789 input_mask
= sig
->input_mask
;
790 oe_mask
= sig
->oe_mask
;
791 invert_input
^= sig
->invert_input
;
792 invert_oe
= sig
->invert_oe
;
793 invert_data
^= sig
->invert_data
;
795 LOG_ERROR("unknown option '%s'", CMD_ARGV
[i
]);
796 return ERROR_COMMAND_SYNTAX_ERROR
;
801 sig
= find_signal_by_name(CMD_ARGV
[0]);
803 sig
= create_signal(CMD_ARGV
[0]);
805 LOG_ERROR("failed to create signal %s", CMD_ARGV
[0]);
809 sig
->invert_data
= invert_data
;
810 sig
->data_mask
= data_mask
;
811 sig
->invert_input
= invert_input
;
812 sig
->input_mask
= input_mask
;
813 sig
->invert_oe
= invert_oe
;
814 sig
->oe_mask
= oe_mask
;
819 COMMAND_HANDLER(ftdi_handle_set_signal_command
)
822 return ERROR_COMMAND_SYNTAX_ERROR
;
825 sig
= find_signal_by_name(CMD_ARGV
[0]);
827 LOG_ERROR("interface configuration doesn't define signal '%s'", CMD_ARGV
[0]);
831 switch (*CMD_ARGV
[1]) {
836 /* single character level specifier only */
837 if (CMD_ARGV
[1][1] == '\0') {
838 ftdi_set_signal(sig
, *CMD_ARGV
[1]);
843 LOG_ERROR("unknown signal level '%s', use 0, 1 or z", CMD_ARGV
[1]);
844 return ERROR_COMMAND_SYNTAX_ERROR
;
847 return mpsse_flush(mpsse_ctx
);
850 COMMAND_HANDLER(ftdi_handle_get_signal_command
)
853 return ERROR_COMMAND_SYNTAX_ERROR
;
856 uint16_t sig_data
= 0;
857 sig
= find_signal_by_name(CMD_ARGV
[0]);
859 LOG_ERROR("interface configuration doesn't define signal '%s'", CMD_ARGV
[0]);
863 int ret
= ftdi_get_signal(sig
, &sig_data
);
867 LOG_USER("Signal %s = %#06x", sig
->name
, sig_data
);
872 COMMAND_HANDLER(ftdi_handle_vid_pid_command
)
874 if (CMD_ARGC
> MAX_USB_IDS
* 2) {
875 LOG_WARNING("ignoring extra IDs in ftdi vid_pid "
876 "(maximum is %d pairs)", MAX_USB_IDS
);
877 CMD_ARGC
= MAX_USB_IDS
* 2;
879 if (CMD_ARGC
< 2 || (CMD_ARGC
& 1)) {
880 LOG_WARNING("incomplete ftdi vid_pid configuration directive");
882 return ERROR_COMMAND_SYNTAX_ERROR
;
883 /* remove the incomplete trailing id */
888 for (i
= 0; i
< CMD_ARGC
; i
+= 2) {
889 COMMAND_PARSE_NUMBER(u16
, CMD_ARGV
[i
], ftdi_vid
[i
>> 1]);
890 COMMAND_PARSE_NUMBER(u16
, CMD_ARGV
[i
+ 1], ftdi_pid
[i
>> 1]);
894 * Explicitly terminate, in case there are multiples instances of
897 ftdi_vid
[i
>> 1] = ftdi_pid
[i
>> 1] = 0;
902 COMMAND_HANDLER(ftdi_handle_tdo_sample_edge_command
)
905 static const struct jim_nvp nvp_ftdi_jtag_modes
[] = {
906 { .name
= "rising", .value
= JTAG_MODE
},
907 { .name
= "falling", .value
= JTAG_MODE_ALT
},
908 { .name
= NULL
, .value
= -1 },
912 n
= jim_nvp_name2value_simple(nvp_ftdi_jtag_modes
, CMD_ARGV
[0]);
914 return ERROR_COMMAND_SYNTAX_ERROR
;
915 ftdi_jtag_mode
= n
->value
;
919 n
= jim_nvp_value2name_simple(nvp_ftdi_jtag_modes
, ftdi_jtag_mode
);
920 command_print(CMD
, "ftdi samples TDO on %s edge of TCK", n
->name
);
925 static const struct command_registration ftdi_subcommand_handlers
[] = {
927 .name
= "device_desc",
928 .handler
= &ftdi_handle_device_desc_command
,
929 .mode
= COMMAND_CONFIG
,
930 .help
= "set the USB device description of the FTDI device",
931 .usage
= "description_string",
935 .handler
= &ftdi_handle_channel_command
,
936 .mode
= COMMAND_CONFIG
,
937 .help
= "set the channel of the FTDI device that is used as JTAG",
941 .name
= "layout_init",
942 .handler
= &ftdi_handle_layout_init_command
,
943 .mode
= COMMAND_CONFIG
,
944 .help
= "initialize the FTDI GPIO signals used "
945 "to control output-enables and reset signals",
946 .usage
= "data direction",
949 .name
= "layout_signal",
950 .handler
= &ftdi_handle_layout_signal_command
,
952 .help
= "define a signal controlled by one or more FTDI GPIO as data "
953 "and/or output enable",
954 .usage
= "name [-data mask|-ndata mask] [-oe mask|-noe mask] [-alias|-nalias name]",
957 .name
= "set_signal",
958 .handler
= &ftdi_handle_set_signal_command
,
959 .mode
= COMMAND_EXEC
,
960 .help
= "control a layout-specific signal",
961 .usage
= "name (1|0|z)",
964 .name
= "get_signal",
965 .handler
= &ftdi_handle_get_signal_command
,
966 .mode
= COMMAND_EXEC
,
967 .help
= "read the value of a layout-specific signal",
972 .handler
= &ftdi_handle_vid_pid_command
,
973 .mode
= COMMAND_CONFIG
,
974 .help
= "the vendor ID and product ID of the FTDI device",
975 .usage
= "(vid pid)*",
978 .name
= "tdo_sample_edge",
979 .handler
= &ftdi_handle_tdo_sample_edge_command
,
981 .help
= "set which TCK clock edge is used for sampling TDO "
982 "- default is rising-edge (Setting to falling-edge may "
983 "allow signalling speed increase)",
984 .usage
= "(rising|falling)",
986 COMMAND_REGISTRATION_DONE
989 static const struct command_registration ftdi_command_handlers
[] = {
993 .help
= "perform ftdi management",
994 .chain
= ftdi_subcommand_handlers
,
997 COMMAND_REGISTRATION_DONE
1000 static int create_default_signal(const char *name
, uint16_t data_mask
)
1002 struct signal
*sig
= create_signal(name
);
1004 LOG_ERROR("failed to create signal %s", name
);
1007 sig
->invert_data
= false;
1008 sig
->data_mask
= data_mask
;
1009 sig
->invert_oe
= false;
1015 static int create_signals(void)
1017 if (create_default_signal("TCK", 0x01) != ERROR_OK
)
1019 if (create_default_signal("TDI", 0x02) != ERROR_OK
)
1021 if (create_default_signal("TDO", 0x04) != ERROR_OK
)
1023 if (create_default_signal("TMS", 0x08) != ERROR_OK
)
1028 static int ftdi_swd_init(void)
1030 LOG_INFO("FTDI SWD mode enabled");
1033 if (create_signals() != ERROR_OK
)
1036 swd_cmd_queue_alloced
= 10;
1037 swd_cmd_queue
= malloc(swd_cmd_queue_alloced
* sizeof(*swd_cmd_queue
));
1039 return swd_cmd_queue
? ERROR_OK
: ERROR_FAIL
;
1042 static void ftdi_swd_swdio_en(bool enable
)
1044 struct signal
*oe
= find_signal_by_name("SWDIO_OE");
1047 ftdi_set_signal(oe
, enable
? '1' : '0');
1049 /* Sets TDI/DO pin to input during rx when both pins are connected
1052 direction
|= jtag_direction_init
& 0x0002U
;
1054 direction
&= ~0x0002U
;
1055 mpsse_set_data_bits_low_byte(mpsse_ctx
, output
& 0xff, direction
& 0xff);
1061 * Flush the MPSSE queue and process the SWD transaction queue
1064 static int ftdi_swd_run_queue(void)
1066 LOG_DEBUG_IO("Executing %zu queued transactions", swd_cmd_queue_length
);
1068 struct signal
*led
= find_signal_by_name("LED");
1070 if (queued_retval
!= ERROR_OK
) {
1071 LOG_DEBUG_IO("Skipping due to previous errors: %d", queued_retval
);
1075 /* A transaction must be followed by another transaction or at least 8 idle cycles to
1076 * ensure that data is clocked through the AP. */
1077 mpsse_clock_data_out(mpsse_ctx
, NULL
, 0, 8, SWD_MODE
);
1079 /* Terminate the "blink", if the current layout has that feature */
1081 ftdi_set_signal(led
, '0');
1083 queued_retval
= mpsse_flush(mpsse_ctx
);
1084 if (queued_retval
!= ERROR_OK
) {
1085 LOG_ERROR("MPSSE failed");
1089 for (size_t i
= 0; i
< swd_cmd_queue_length
; i
++) {
1090 int ack
= buf_get_u32(swd_cmd_queue
[i
].trn_ack_data_parity_trn
, 1, 3);
1092 /* Devices do not reply to DP_TARGETSEL write cmd, ignore received ack */
1093 bool check_ack
= swd_cmd_returns_ack(swd_cmd_queue
[i
].cmd
);
1095 LOG_DEBUG_IO("%s%s %s %s reg %X = %08"PRIx32
,
1096 check_ack
? "" : "ack ignored ",
1097 ack
== SWD_ACK_OK
? "OK" : ack
== SWD_ACK_WAIT
? "WAIT" : ack
== SWD_ACK_FAULT
? "FAULT" : "JUNK",
1098 swd_cmd_queue
[i
].cmd
& SWD_CMD_APNDP
? "AP" : "DP",
1099 swd_cmd_queue
[i
].cmd
& SWD_CMD_RNW
? "read" : "write",
1100 (swd_cmd_queue
[i
].cmd
& SWD_CMD_A32
) >> 1,
1101 buf_get_u32(swd_cmd_queue
[i
].trn_ack_data_parity_trn
,
1102 1 + 3 + (swd_cmd_queue
[i
].cmd
& SWD_CMD_RNW
? 0 : 1), 32));
1104 if (ack
!= SWD_ACK_OK
&& check_ack
) {
1105 queued_retval
= swd_ack_to_error_code(ack
);
1108 } else if (swd_cmd_queue
[i
].cmd
& SWD_CMD_RNW
) {
1109 uint32_t data
= buf_get_u32(swd_cmd_queue
[i
].trn_ack_data_parity_trn
, 1 + 3, 32);
1110 int parity
= buf_get_u32(swd_cmd_queue
[i
].trn_ack_data_parity_trn
, 1 + 3 + 32, 1);
1112 if (parity
!= parity_u32(data
)) {
1113 LOG_ERROR("SWD Read data parity mismatch");
1114 queued_retval
= ERROR_FAIL
;
1118 if (swd_cmd_queue
[i
].dst
)
1119 *swd_cmd_queue
[i
].dst
= data
;
1124 swd_cmd_queue_length
= 0;
1125 retval
= queued_retval
;
1126 queued_retval
= ERROR_OK
;
1128 /* Queue a new "blink" */
1129 if (led
&& retval
== ERROR_OK
)
1130 ftdi_set_signal(led
, '1');
1135 static void ftdi_swd_queue_cmd(uint8_t cmd
, uint32_t *dst
, uint32_t data
, uint32_t ap_delay_clk
)
1137 if (swd_cmd_queue_length
>= swd_cmd_queue_alloced
) {
1138 /* Not enough room in the queue. Run the queue and increase its size for next time.
1139 * Note that it's not possible to avoid running the queue here, because mpsse contains
1140 * pointers into the queue which may be invalid after the realloc. */
1141 queued_retval
= ftdi_swd_run_queue();
1142 struct swd_cmd_queue_entry
*q
= realloc(swd_cmd_queue
, swd_cmd_queue_alloced
* 2 * sizeof(*swd_cmd_queue
));
1145 swd_cmd_queue_alloced
*= 2;
1146 LOG_DEBUG("Increased SWD command queue to %zu elements", swd_cmd_queue_alloced
);
1150 if (queued_retval
!= ERROR_OK
)
1153 size_t i
= swd_cmd_queue_length
++;
1154 swd_cmd_queue
[i
].cmd
= cmd
| SWD_CMD_START
| SWD_CMD_PARK
;
1156 mpsse_clock_data_out(mpsse_ctx
, &swd_cmd_queue
[i
].cmd
, 0, 8, SWD_MODE
);
1158 if (swd_cmd_queue
[i
].cmd
& SWD_CMD_RNW
) {
1159 /* Queue a read transaction */
1160 swd_cmd_queue
[i
].dst
= dst
;
1162 ftdi_swd_swdio_en(false);
1163 mpsse_clock_data_in(mpsse_ctx
, swd_cmd_queue
[i
].trn_ack_data_parity_trn
,
1164 0, 1 + 3 + 32 + 1 + 1, SWD_MODE
);
1165 ftdi_swd_swdio_en(true);
1167 /* Queue a write transaction */
1168 ftdi_swd_swdio_en(false);
1170 mpsse_clock_data_in(mpsse_ctx
, swd_cmd_queue
[i
].trn_ack_data_parity_trn
,
1171 0, 1 + 3 + 1, SWD_MODE
);
1173 ftdi_swd_swdio_en(true);
1175 buf_set_u32(swd_cmd_queue
[i
].trn_ack_data_parity_trn
, 1 + 3 + 1, 32, data
);
1176 buf_set_u32(swd_cmd_queue
[i
].trn_ack_data_parity_trn
, 1 + 3 + 1 + 32, 1, parity_u32(data
));
1178 mpsse_clock_data_out(mpsse_ctx
, swd_cmd_queue
[i
].trn_ack_data_parity_trn
,
1179 1 + 3 + 1, 32 + 1, SWD_MODE
);
1182 /* Insert idle cycles after AP accesses to avoid WAIT */
1183 if (cmd
& SWD_CMD_APNDP
)
1184 mpsse_clock_data_out(mpsse_ctx
, NULL
, 0, ap_delay_clk
, SWD_MODE
);
1188 static void ftdi_swd_read_reg(uint8_t cmd
, uint32_t *value
, uint32_t ap_delay_clk
)
1190 assert(cmd
& SWD_CMD_RNW
);
1191 ftdi_swd_queue_cmd(cmd
, value
, 0, ap_delay_clk
);
1194 static void ftdi_swd_write_reg(uint8_t cmd
, uint32_t value
, uint32_t ap_delay_clk
)
1196 assert(!(cmd
& SWD_CMD_RNW
));
1197 ftdi_swd_queue_cmd(cmd
, NULL
, value
, ap_delay_clk
);
1200 static int ftdi_swd_switch_seq(enum swd_special_seq seq
)
1204 LOG_DEBUG("SWD line reset");
1205 ftdi_swd_swdio_en(true);
1206 mpsse_clock_data_out(mpsse_ctx
, swd_seq_line_reset
, 0, swd_seq_line_reset_len
, SWD_MODE
);
1209 LOG_DEBUG("JTAG-to-SWD");
1210 ftdi_swd_swdio_en(true);
1211 mpsse_clock_data_out(mpsse_ctx
, swd_seq_jtag_to_swd
, 0, swd_seq_jtag_to_swd_len
, SWD_MODE
);
1213 case JTAG_TO_DORMANT
:
1214 LOG_DEBUG("JTAG-to-DORMANT");
1215 ftdi_swd_swdio_en(true);
1216 mpsse_clock_data_out(mpsse_ctx
, swd_seq_jtag_to_dormant
, 0, swd_seq_jtag_to_dormant_len
, SWD_MODE
);
1219 LOG_DEBUG("SWD-to-JTAG");
1220 ftdi_swd_swdio_en(true);
1221 mpsse_clock_data_out(mpsse_ctx
, swd_seq_swd_to_jtag
, 0, swd_seq_swd_to_jtag_len
, SWD_MODE
);
1223 case SWD_TO_DORMANT
:
1224 LOG_DEBUG("SWD-to-DORMANT");
1225 ftdi_swd_swdio_en(true);
1226 mpsse_clock_data_out(mpsse_ctx
, swd_seq_swd_to_dormant
, 0, swd_seq_swd_to_dormant_len
, SWD_MODE
);
1228 case DORMANT_TO_SWD
:
1229 LOG_DEBUG("DORMANT-to-SWD");
1230 ftdi_swd_swdio_en(true);
1231 mpsse_clock_data_out(mpsse_ctx
, swd_seq_dormant_to_swd
, 0, swd_seq_dormant_to_swd_len
, SWD_MODE
);
1233 case DORMANT_TO_JTAG
:
1234 LOG_DEBUG("DORMANT-to-JTAG");
1235 ftdi_swd_swdio_en(true);
1236 mpsse_clock_data_out(mpsse_ctx
, swd_seq_dormant_to_jtag
, 0, swd_seq_dormant_to_jtag_len
, SWD_MODE
);
1239 LOG_ERROR("Sequence %d not supported", seq
);
1246 static const struct swd_driver ftdi_swd
= {
1247 .init
= ftdi_swd_init
,
1248 .switch_seq
= ftdi_swd_switch_seq
,
1249 .read_reg
= ftdi_swd_read_reg
,
1250 .write_reg
= ftdi_swd_write_reg
,
1251 .run
= ftdi_swd_run_queue
,
1254 static const char * const ftdi_transports
[] = { "jtag", "swd", NULL
};
1256 static struct jtag_interface ftdi_interface
= {
1257 .supported
= DEBUG_CAP_TMS_SEQ
,
1258 .execute_queue
= ftdi_execute_queue
,
1261 struct adapter_driver ftdi_adapter_driver
= {
1263 .transports
= ftdi_transports
,
1264 .commands
= ftdi_command_handlers
,
1266 .init
= ftdi_initialize
,
1268 .reset
= ftdi_reset
,
1269 .speed
= ftdi_speed
,
1271 .speed_div
= ftdi_speed_div
,
1273 .jtag_ops
= &ftdi_interface
,
1274 .swd_ops
= &ftdi_swd
,
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)