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, see <http://www.gnu.org/licenses/>. *
17 ***************************************************************************/
21 * JTAG adapters based on the FT2232 full and high speed USB parts are
22 * popular low cost JTAG debug solutions. Many FT2232 based JTAG adapters
23 * are discrete, but development boards may integrate them as alternatives
24 * to more capable (and expensive) third party JTAG pods.
26 * JTAG uses only one of the two communications channels ("MPSSE engines")
27 * on these devices. Adapters based on FT4232 parts have four ports/channels
28 * (A/B/C/D), instead of just two (A/B).
30 * Especially on development boards integrating one of these chips (as
31 * opposed to discrete pods/dongles), the additional channels can be used
32 * for a variety of purposes, but OpenOCD only uses one channel at a time.
34 * - As a USB-to-serial adapter for the target's console UART ...
35 * which may be able to support ROM boot loaders that load initial
36 * firmware images to flash (or SRAM).
38 * - On systems which support ARM's SWD in addition to JTAG, or instead
39 * of it, that second port can be used for reading SWV/SWO trace data.
41 * - Additional JTAG links, e.g. to a CPLD or * FPGA.
43 * FT2232 based JTAG adapters are "dumb" not "smart", because most JTAG
44 * request/response interactions involve round trips over the USB link.
45 * A "smart" JTAG adapter has intelligence close to the scan chain, so it
46 * can for example poll quickly for a status change (usually taking on the
47 * order of microseconds not milliseconds) before beginning a queued
48 * transaction which require the previous one to have completed.
50 * There are dozens of adapters of this type, differing in details which
51 * this driver needs to understand. Those "layout" details are required
52 * as part of FT2232 driver configuration.
54 * This code uses information contained in the MPSSE specification which was
56 * https://www.ftdichip.com/Support/Documents/AppNotes/AN2232C-01_MPSSE_Cmnd.pdf
57 * Hereafter this is called the "MPSSE Spec".
59 * The datasheet for the ftdichip.com's FT2232H part is here:
60 * https://www.ftdichip.com/Support/Documents/DataSheets/ICs/DS_FT2232H.pdf
62 * Also note the issue with code 0x4b (clock data to TMS) noted in
63 * http://developer.intra2net.com/mailarchive/html/libftdi/2009/msg00292.html
64 * which can affect longer JTAG state paths.
71 /* project specific includes */
72 #include <jtag/adapter.h>
73 #include <jtag/interface.h>
75 #include <transport/transport.h>
76 #include <helper/time_support.h>
77 #include <helper/log.h>
85 /* FTDI access library includes */
88 #define JTAG_MODE (LSB_FIRST | POS_EDGE_IN | NEG_EDGE_OUT)
89 #define JTAG_MODE_ALT (LSB_FIRST | NEG_EDGE_IN | NEG_EDGE_OUT)
90 #define SWD_MODE (LSB_FIRST | POS_EDGE_IN | NEG_EDGE_OUT)
92 static char *ftdi_device_desc
;
93 static uint8_t ftdi_channel
;
94 static uint8_t ftdi_jtag_mode
= JTAG_MODE
;
99 /* vid = pid = 0 marks the end of the list */
100 static uint16_t ftdi_vid
[MAX_USB_IDS
+ 1] = { 0 };
101 static uint16_t ftdi_pid
[MAX_USB_IDS
+ 1] = { 0 };
103 static struct mpsse_ctx
*mpsse_ctx
;
116 static struct signal
*signals
;
118 /* FIXME: Where to store per-instance data? We need an SWD context. */
119 static struct swd_cmd_queue_entry
{
122 uint8_t trn_ack_data_parity_trn
[DIV_ROUND_UP(4 + 3 + 32 + 1 + 4, 8)];
124 static size_t swd_cmd_queue_length
;
125 static size_t swd_cmd_queue_alloced
;
126 static int queued_retval
;
129 static uint16_t output
;
130 static uint16_t direction
;
131 static uint16_t jtag_output_init
;
132 static uint16_t jtag_direction_init
;
134 static int ftdi_swd_switch_seq(enum swd_special_seq seq
);
136 static struct signal
*find_signal_by_name(const char *name
)
138 for (struct signal
*sig
= signals
; sig
; sig
= sig
->next
) {
139 if (strcmp(name
, sig
->name
) == 0)
145 static struct signal
*create_signal(const char *name
)
147 struct signal
**psig
= &signals
;
149 psig
= &(*psig
)->next
;
151 *psig
= calloc(1, sizeof(**psig
));
155 (*psig
)->name
= strdup(name
);
156 if (!(*psig
)->name
) {
163 static int ftdi_set_signal(const struct signal
*s
, char value
)
168 if (s
->data_mask
== 0 && s
->oe_mask
== 0) {
169 LOG_ERROR("interface doesn't provide signal '%s'", s
->name
);
174 data
= s
->invert_data
;
178 if (s
->data_mask
== 0) {
179 LOG_ERROR("interface can't drive '%s' high", s
->name
);
182 data
= !s
->invert_data
;
187 if (s
->oe_mask
== 0) {
188 LOG_ERROR("interface can't tri-state '%s'", s
->name
);
191 data
= s
->invert_data
;
195 assert(0 && "invalid signal level specifier");
199 uint16_t old_output
= output
;
200 uint16_t old_direction
= direction
;
202 output
= data
? output
| s
->data_mask
: output
& ~s
->data_mask
;
203 if (s
->oe_mask
== s
->data_mask
)
204 direction
= oe
? direction
| s
->oe_mask
: direction
& ~s
->oe_mask
;
206 output
= oe
? output
| s
->oe_mask
: output
& ~s
->oe_mask
;
208 if ((output
& 0xff) != (old_output
& 0xff) || (direction
& 0xff) != (old_direction
& 0xff))
209 mpsse_set_data_bits_low_byte(mpsse_ctx
, output
& 0xff, direction
& 0xff);
210 if ((output
>> 8 != old_output
>> 8) || (direction
>> 8 != old_direction
>> 8))
211 mpsse_set_data_bits_high_byte(mpsse_ctx
, output
>> 8, direction
>> 8);
216 static int ftdi_get_signal(const struct signal
*s
, uint16_t *value_out
)
218 uint8_t data_low
= 0;
219 uint8_t data_high
= 0;
221 if (s
->input_mask
== 0) {
222 LOG_ERROR("interface doesn't provide signal '%s'", s
->name
);
226 if (s
->input_mask
& 0xff)
227 mpsse_read_data_bits_low_byte(mpsse_ctx
, &data_low
);
228 if (s
->input_mask
>> 8)
229 mpsse_read_data_bits_high_byte(mpsse_ctx
, &data_high
);
231 mpsse_flush(mpsse_ctx
);
233 *value_out
= (((uint16_t)data_high
) << 8) | data_low
;
236 *value_out
= ~(*value_out
);
238 *value_out
&= s
->input_mask
;
244 * Function move_to_state
245 * moves the TAP controller from the current state to a
246 * \a goal_state through a path given by tap_get_tms_path(). State transition
247 * logging is performed by delegation to clock_tms().
249 * @param goal_state is the destination state for the move.
251 static void move_to_state(tap_state_t goal_state
)
253 tap_state_t start_state
= tap_get_state();
255 /* goal_state is 1/2 of a tuple/pair of states which allow convenient
256 lookup of the required TMS pattern to move to this state from the
260 /* do the 2 lookups */
261 uint8_t tms_bits
= tap_get_tms_path(start_state
, goal_state
);
262 int tms_count
= tap_get_tms_path_len(start_state
, goal_state
);
263 assert(tms_count
<= 8);
265 LOG_DEBUG_IO("start=%s goal=%s", tap_state_name(start_state
), tap_state_name(goal_state
));
267 /* Track state transitions step by step */
268 for (int i
= 0; i
< tms_count
; i
++)
269 tap_set_state(tap_state_transition(tap_get_state(), (tms_bits
>> i
) & 1));
271 mpsse_clock_tms_cs_out(mpsse_ctx
,
279 static int ftdi_speed(int speed
)
282 retval
= mpsse_set_frequency(mpsse_ctx
, speed
);
285 LOG_ERROR("couldn't set FTDI TCK speed");
289 if (!swd_mode
&& speed
>= 10000000 && ftdi_jtag_mode
!= JTAG_MODE_ALT
)
290 LOG_INFO("ftdi: if you experience problems at higher adapter clocks, try "
291 "the command \"ftdi tdo_sample_edge falling\"");
295 static int ftdi_speed_div(int speed
, int *khz
)
301 static int ftdi_khz(int khz
, int *jtag_speed
)
303 if (khz
== 0 && !mpsse_is_high_speed(mpsse_ctx
)) {
304 LOG_DEBUG("RCLK not supported");
308 *jtag_speed
= khz
* 1000;
312 static void ftdi_end_state(tap_state_t state
)
314 if (tap_is_state_stable(state
))
315 tap_set_end_state(state
);
317 LOG_ERROR("BUG: %s is not a stable end state", tap_state_name(state
));
322 static void ftdi_execute_runtest(struct jtag_command
*cmd
)
327 LOG_DEBUG_IO("runtest %i cycles, end in %s",
328 cmd
->cmd
.runtest
->num_cycles
,
329 tap_state_name(cmd
->cmd
.runtest
->end_state
));
331 if (tap_get_state() != TAP_IDLE
)
332 move_to_state(TAP_IDLE
);
334 /* TODO: Reuse ftdi_execute_stableclocks */
335 i
= cmd
->cmd
.runtest
->num_cycles
;
337 /* there are no state transitions in this code, so omit state tracking */
338 unsigned this_len
= i
> 7 ? 7 : i
;
339 mpsse_clock_tms_cs_out(mpsse_ctx
, &zero
, 0, this_len
, false, ftdi_jtag_mode
);
343 ftdi_end_state(cmd
->cmd
.runtest
->end_state
);
345 if (tap_get_state() != tap_get_end_state())
346 move_to_state(tap_get_end_state());
348 LOG_DEBUG_IO("runtest: %i, end in %s",
349 cmd
->cmd
.runtest
->num_cycles
,
350 tap_state_name(tap_get_end_state()));
353 static void ftdi_execute_statemove(struct jtag_command
*cmd
)
355 LOG_DEBUG_IO("statemove end in %s",
356 tap_state_name(cmd
->cmd
.statemove
->end_state
));
358 ftdi_end_state(cmd
->cmd
.statemove
->end_state
);
360 /* shortest-path move to desired end state */
361 if (tap_get_state() != tap_get_end_state() || tap_get_end_state() == TAP_RESET
)
362 move_to_state(tap_get_end_state());
366 * Clock a bunch of TMS (or SWDIO) transitions, to change the JTAG
367 * (or SWD) state machine. REVISIT: Not the best method, perhaps.
369 static void ftdi_execute_tms(struct jtag_command
*cmd
)
371 LOG_DEBUG_IO("TMS: %d bits", cmd
->cmd
.tms
->num_bits
);
373 /* TODO: Missing tap state tracking, also missing from ft2232.c! */
374 mpsse_clock_tms_cs_out(mpsse_ctx
,
377 cmd
->cmd
.tms
->num_bits
,
382 static void ftdi_execute_pathmove(struct jtag_command
*cmd
)
384 tap_state_t
*path
= cmd
->cmd
.pathmove
->path
;
385 int num_states
= cmd
->cmd
.pathmove
->num_states
;
387 LOG_DEBUG_IO("pathmove: %i states, current: %s end: %s", num_states
,
388 tap_state_name(tap_get_state()),
389 tap_state_name(path
[num_states
-1]));
392 unsigned bit_count
= 0;
393 uint8_t tms_byte
= 0;
397 /* this loop verifies that the path is legal and logs each state in the path */
398 while (num_states
--) {
400 /* either TMS=0 or TMS=1 must work ... */
401 if (tap_state_transition(tap_get_state(), false)
402 == path
[state_count
])
403 buf_set_u32(&tms_byte
, bit_count
++, 1, 0x0);
404 else if (tap_state_transition(tap_get_state(), true)
405 == path
[state_count
]) {
406 buf_set_u32(&tms_byte
, bit_count
++, 1, 0x1);
408 /* ... or else the caller goofed BADLY */
410 LOG_ERROR("BUG: %s -> %s isn't a valid "
411 "TAP state transition",
412 tap_state_name(tap_get_state()),
413 tap_state_name(path
[state_count
]));
417 tap_set_state(path
[state_count
]);
420 if (bit_count
== 7 || num_states
== 0) {
421 mpsse_clock_tms_cs_out(mpsse_ctx
,
430 tap_set_end_state(tap_get_state());
433 static void ftdi_execute_scan(struct jtag_command
*cmd
)
435 LOG_DEBUG_IO("%s type:%d", cmd
->cmd
.scan
->ir_scan
? "IRSCAN" : "DRSCAN",
436 jtag_scan_type(cmd
->cmd
.scan
));
438 /* Make sure there are no trailing fields with num_bits == 0, or the logic below will fail. */
439 while (cmd
->cmd
.scan
->num_fields
> 0
440 && cmd
->cmd
.scan
->fields
[cmd
->cmd
.scan
->num_fields
- 1].num_bits
== 0) {
441 cmd
->cmd
.scan
->num_fields
--;
442 LOG_DEBUG_IO("discarding trailing empty field");
445 if (cmd
->cmd
.scan
->num_fields
== 0) {
446 LOG_DEBUG_IO("empty scan, doing nothing");
450 if (cmd
->cmd
.scan
->ir_scan
) {
451 if (tap_get_state() != TAP_IRSHIFT
)
452 move_to_state(TAP_IRSHIFT
);
454 if (tap_get_state() != TAP_DRSHIFT
)
455 move_to_state(TAP_DRSHIFT
);
458 ftdi_end_state(cmd
->cmd
.scan
->end_state
);
460 struct scan_field
*field
= cmd
->cmd
.scan
->fields
;
461 unsigned scan_size
= 0;
463 for (int i
= 0; i
< cmd
->cmd
.scan
->num_fields
; i
++, field
++) {
464 scan_size
+= field
->num_bits
;
465 LOG_DEBUG_IO("%s%s field %d/%d %d bits",
466 field
->in_value
? "in" : "",
467 field
->out_value
? "out" : "",
469 cmd
->cmd
.scan
->num_fields
,
472 if (i
== cmd
->cmd
.scan
->num_fields
- 1 && tap_get_state() != tap_get_end_state()) {
473 /* Last field, and we're leaving IRSHIFT/DRSHIFT. Clock last bit during tap
474 * movement. This last field can't have length zero, it was checked above. */
475 mpsse_clock_data(mpsse_ctx
,
482 uint8_t last_bit
= 0;
483 if (field
->out_value
)
484 bit_copy(&last_bit
, 0, field
->out_value
, field
->num_bits
- 1, 1);
486 /* If endstate is TAP_IDLE, clock out 1-1-0 (->EXIT1 ->UPDATE ->IDLE)
487 * Otherwise, clock out 1-0 (->EXIT1 ->PAUSE)
489 uint8_t tms_bits
= 0x03;
490 mpsse_clock_tms_cs(mpsse_ctx
,
498 tap_set_state(tap_state_transition(tap_get_state(), 1));
499 if (tap_get_end_state() == TAP_IDLE
) {
500 mpsse_clock_tms_cs_out(mpsse_ctx
,
506 tap_set_state(tap_state_transition(tap_get_state(), 1));
507 tap_set_state(tap_state_transition(tap_get_state(), 0));
509 mpsse_clock_tms_cs_out(mpsse_ctx
,
515 tap_set_state(tap_state_transition(tap_get_state(), 0));
518 mpsse_clock_data(mpsse_ctx
,
527 if (tap_get_state() != tap_get_end_state())
528 move_to_state(tap_get_end_state());
530 LOG_DEBUG_IO("%s scan, %i bits, end in %s",
531 (cmd
->cmd
.scan
->ir_scan
) ? "IR" : "DR", scan_size
,
532 tap_state_name(tap_get_end_state()));
535 static int ftdi_reset(int trst
, int srst
)
537 struct signal
*sig_ntrst
= find_signal_by_name("nTRST");
538 struct signal
*sig_nsrst
= find_signal_by_name("nSRST");
540 LOG_DEBUG_IO("reset trst: %i srst %i", trst
, srst
);
545 ftdi_set_signal(sig_ntrst
, '0');
547 LOG_ERROR("Can't assert TRST: nTRST signal is not defined");
548 } else if (sig_ntrst
&& jtag_get_reset_config() & RESET_HAS_TRST
&&
550 if (jtag_get_reset_config() & RESET_TRST_OPEN_DRAIN
)
551 ftdi_set_signal(sig_ntrst
, 'z');
553 ftdi_set_signal(sig_ntrst
, '1');
559 ftdi_set_signal(sig_nsrst
, '0');
561 LOG_ERROR("Can't assert SRST: nSRST signal is not defined");
562 } else if (sig_nsrst
&& jtag_get_reset_config() & RESET_HAS_SRST
&&
564 if (jtag_get_reset_config() & RESET_SRST_PUSH_PULL
)
565 ftdi_set_signal(sig_nsrst
, '1');
567 ftdi_set_signal(sig_nsrst
, 'z');
570 return mpsse_flush(mpsse_ctx
);
573 static void ftdi_execute_sleep(struct jtag_command
*cmd
)
575 LOG_DEBUG_IO("sleep %" PRIu32
, cmd
->cmd
.sleep
->us
);
577 mpsse_flush(mpsse_ctx
);
578 jtag_sleep(cmd
->cmd
.sleep
->us
);
579 LOG_DEBUG_IO("sleep %" PRIu32
" usec while in %s",
581 tap_state_name(tap_get_state()));
584 static void ftdi_execute_stableclocks(struct jtag_command
*cmd
)
586 /* this is only allowed while in a stable state. A check for a stable
587 * state was done in jtag_add_clocks()
589 int num_cycles
= cmd
->cmd
.stableclocks
->num_cycles
;
591 /* 7 bits of either ones or zeros. */
592 uint8_t tms
= tap_get_state() == TAP_RESET
? 0x7f : 0x00;
594 /* TODO: Use mpsse_clock_data with in=out=0 for this, if TMS can be set to
595 * the correct level and remain there during the scan */
596 while (num_cycles
> 0) {
597 /* there are no state transitions in this code, so omit state tracking */
598 unsigned this_len
= num_cycles
> 7 ? 7 : num_cycles
;
599 mpsse_clock_tms_cs_out(mpsse_ctx
, &tms
, 0, this_len
, false, ftdi_jtag_mode
);
600 num_cycles
-= this_len
;
603 LOG_DEBUG_IO("clocks %i while in %s",
604 cmd
->cmd
.stableclocks
->num_cycles
,
605 tap_state_name(tap_get_state()));
608 static void ftdi_execute_command(struct jtag_command
*cmd
)
612 ftdi_execute_runtest(cmd
);
615 ftdi_execute_statemove(cmd
);
618 ftdi_execute_pathmove(cmd
);
621 ftdi_execute_scan(cmd
);
624 ftdi_execute_sleep(cmd
);
626 case JTAG_STABLECLOCKS
:
627 ftdi_execute_stableclocks(cmd
);
630 ftdi_execute_tms(cmd
);
633 LOG_ERROR("BUG: unknown JTAG command type encountered: %d", cmd
->type
);
638 static int ftdi_execute_queue(void)
640 /* blink, if the current layout has that feature */
641 struct signal
*led
= find_signal_by_name("LED");
643 ftdi_set_signal(led
, '1');
645 for (struct jtag_command
*cmd
= jtag_command_queue
; cmd
; cmd
= cmd
->next
) {
646 /* fill the write buffer with the desired command */
647 ftdi_execute_command(cmd
);
651 ftdi_set_signal(led
, '0');
653 int retval
= mpsse_flush(mpsse_ctx
);
654 if (retval
!= ERROR_OK
)
655 LOG_ERROR("error while flushing MPSSE queue: %d", retval
);
660 static int ftdi_initialize(void)
662 if (tap_get_tms_path_len(TAP_IRPAUSE
, TAP_IRPAUSE
) == 7)
663 LOG_DEBUG("ftdi interface using 7 step jtag state transitions");
665 LOG_DEBUG("ftdi interface using shortest path jtag state transitions");
667 if (!ftdi_vid
[0] && !ftdi_pid
[0]) {
668 LOG_ERROR("Please specify ftdi vid_pid");
669 return ERROR_JTAG_INIT_FAILED
;
672 for (int i
= 0; ftdi_vid
[i
] || ftdi_pid
[i
]; i
++) {
673 mpsse_ctx
= mpsse_open(&ftdi_vid
[i
], &ftdi_pid
[i
], ftdi_device_desc
,
674 adapter_get_required_serial(), adapter_usb_get_location(), ftdi_channel
);
680 return ERROR_JTAG_INIT_FAILED
;
682 output
= jtag_output_init
;
683 direction
= jtag_direction_init
;
686 struct signal
*sig
= find_signal_by_name("SWD_EN");
688 LOG_ERROR("SWD mode is active but SWD_EN signal is not defined");
689 return ERROR_JTAG_INIT_FAILED
;
691 /* A dummy SWD_EN would have zero mask */
693 ftdi_set_signal(sig
, '1');
696 mpsse_set_data_bits_low_byte(mpsse_ctx
, output
& 0xff, direction
& 0xff);
697 mpsse_set_data_bits_high_byte(mpsse_ctx
, output
>> 8, direction
>> 8);
699 mpsse_loopback_config(mpsse_ctx
, false);
701 freq
= mpsse_set_frequency(mpsse_ctx
, adapter_get_speed_khz() * 1000);
703 return mpsse_flush(mpsse_ctx
);
706 static int ftdi_quit(void)
708 mpsse_close(mpsse_ctx
);
710 struct signal
*sig
= signals
;
712 struct signal
*next
= sig
->next
;
713 free((void *)sig
->name
);
718 free(ftdi_device_desc
);
725 COMMAND_HANDLER(ftdi_handle_device_desc_command
)
728 free(ftdi_device_desc
);
729 ftdi_device_desc
= strdup(CMD_ARGV
[0]);
731 LOG_ERROR("expected exactly one argument to ftdi device_desc <description>");
737 COMMAND_HANDLER(ftdi_handle_channel_command
)
740 COMMAND_PARSE_NUMBER(u8
, CMD_ARGV
[0], ftdi_channel
);
742 return ERROR_COMMAND_SYNTAX_ERROR
;
747 COMMAND_HANDLER(ftdi_handle_layout_init_command
)
750 return ERROR_COMMAND_SYNTAX_ERROR
;
752 COMMAND_PARSE_NUMBER(u16
, CMD_ARGV
[0], jtag_output_init
);
753 COMMAND_PARSE_NUMBER(u16
, CMD_ARGV
[1], jtag_direction_init
);
758 COMMAND_HANDLER(ftdi_handle_layout_signal_command
)
761 return ERROR_COMMAND_SYNTAX_ERROR
;
763 bool invert_data
= false;
764 uint16_t data_mask
= 0;
765 bool invert_input
= false;
766 uint16_t input_mask
= 0;
767 bool invert_oe
= false;
768 uint16_t oe_mask
= 0;
769 for (unsigned i
= 1; i
< CMD_ARGC
; i
+= 2) {
770 if (strcmp("-data", CMD_ARGV
[i
]) == 0) {
772 COMMAND_PARSE_NUMBER(u16
, CMD_ARGV
[i
+ 1], data_mask
);
773 } else if (strcmp("-ndata", CMD_ARGV
[i
]) == 0) {
775 COMMAND_PARSE_NUMBER(u16
, CMD_ARGV
[i
+ 1], data_mask
);
776 } else if (strcmp("-input", CMD_ARGV
[i
]) == 0) {
777 invert_input
= false;
778 COMMAND_PARSE_NUMBER(u16
, CMD_ARGV
[i
+ 1], input_mask
);
779 } else if (strcmp("-ninput", CMD_ARGV
[i
]) == 0) {
781 COMMAND_PARSE_NUMBER(u16
, CMD_ARGV
[i
+ 1], input_mask
);
782 } else if (strcmp("-oe", CMD_ARGV
[i
]) == 0) {
784 COMMAND_PARSE_NUMBER(u16
, CMD_ARGV
[i
+ 1], oe_mask
);
785 } else if (strcmp("-noe", CMD_ARGV
[i
]) == 0) {
787 COMMAND_PARSE_NUMBER(u16
, CMD_ARGV
[i
+ 1], oe_mask
);
788 } else if (!strcmp("-alias", CMD_ARGV
[i
]) ||
789 !strcmp("-nalias", CMD_ARGV
[i
])) {
790 if (!strcmp("-nalias", CMD_ARGV
[i
])) {
794 struct signal
*sig
= find_signal_by_name(CMD_ARGV
[i
+ 1]);
796 LOG_ERROR("signal %s is not defined", CMD_ARGV
[i
+ 1]);
799 data_mask
= sig
->data_mask
;
800 input_mask
= sig
->input_mask
;
801 oe_mask
= sig
->oe_mask
;
802 invert_input
^= sig
->invert_input
;
803 invert_oe
= sig
->invert_oe
;
804 invert_data
^= sig
->invert_data
;
806 LOG_ERROR("unknown option '%s'", CMD_ARGV
[i
]);
807 return ERROR_COMMAND_SYNTAX_ERROR
;
812 sig
= find_signal_by_name(CMD_ARGV
[0]);
814 sig
= create_signal(CMD_ARGV
[0]);
816 LOG_ERROR("failed to create signal %s", CMD_ARGV
[0]);
820 sig
->invert_data
= invert_data
;
821 sig
->data_mask
= data_mask
;
822 sig
->invert_input
= invert_input
;
823 sig
->input_mask
= input_mask
;
824 sig
->invert_oe
= invert_oe
;
825 sig
->oe_mask
= oe_mask
;
830 COMMAND_HANDLER(ftdi_handle_set_signal_command
)
833 return ERROR_COMMAND_SYNTAX_ERROR
;
836 sig
= find_signal_by_name(CMD_ARGV
[0]);
838 LOG_ERROR("interface configuration doesn't define signal '%s'", CMD_ARGV
[0]);
842 switch (*CMD_ARGV
[1]) {
847 /* single character level specifier only */
848 if (CMD_ARGV
[1][1] == '\0') {
849 ftdi_set_signal(sig
, *CMD_ARGV
[1]);
854 LOG_ERROR("unknown signal level '%s', use 0, 1 or z", CMD_ARGV
[1]);
855 return ERROR_COMMAND_SYNTAX_ERROR
;
858 return mpsse_flush(mpsse_ctx
);
861 COMMAND_HANDLER(ftdi_handle_get_signal_command
)
864 return ERROR_COMMAND_SYNTAX_ERROR
;
867 uint16_t sig_data
= 0;
868 sig
= find_signal_by_name(CMD_ARGV
[0]);
870 LOG_ERROR("interface configuration doesn't define signal '%s'", CMD_ARGV
[0]);
874 int ret
= ftdi_get_signal(sig
, &sig_data
);
878 LOG_USER("Signal %s = %#06x", sig
->name
, sig_data
);
883 COMMAND_HANDLER(ftdi_handle_vid_pid_command
)
885 if (CMD_ARGC
> MAX_USB_IDS
* 2) {
886 LOG_WARNING("ignoring extra IDs in ftdi vid_pid "
887 "(maximum is %d pairs)", MAX_USB_IDS
);
888 CMD_ARGC
= MAX_USB_IDS
* 2;
890 if (CMD_ARGC
< 2 || (CMD_ARGC
& 1)) {
891 LOG_WARNING("incomplete ftdi vid_pid configuration directive");
893 return ERROR_COMMAND_SYNTAX_ERROR
;
894 /* remove the incomplete trailing id */
899 for (i
= 0; i
< CMD_ARGC
; i
+= 2) {
900 COMMAND_PARSE_NUMBER(u16
, CMD_ARGV
[i
], ftdi_vid
[i
>> 1]);
901 COMMAND_PARSE_NUMBER(u16
, CMD_ARGV
[i
+ 1], ftdi_pid
[i
>> 1]);
905 * Explicitly terminate, in case there are multiples instances of
908 ftdi_vid
[i
>> 1] = ftdi_pid
[i
>> 1] = 0;
913 COMMAND_HANDLER(ftdi_handle_tdo_sample_edge_command
)
916 static const struct jim_nvp nvp_ftdi_jtag_modes
[] = {
917 { .name
= "rising", .value
= JTAG_MODE
},
918 { .name
= "falling", .value
= JTAG_MODE_ALT
},
919 { .name
= NULL
, .value
= -1 },
923 n
= jim_nvp_name2value_simple(nvp_ftdi_jtag_modes
, CMD_ARGV
[0]);
925 return ERROR_COMMAND_SYNTAX_ERROR
;
926 ftdi_jtag_mode
= n
->value
;
930 n
= jim_nvp_value2name_simple(nvp_ftdi_jtag_modes
, ftdi_jtag_mode
);
931 command_print(CMD
, "ftdi samples TDO on %s edge of TCK", n
->name
);
936 static const struct command_registration ftdi_subcommand_handlers
[] = {
938 .name
= "device_desc",
939 .handler
= &ftdi_handle_device_desc_command
,
940 .mode
= COMMAND_CONFIG
,
941 .help
= "set the USB device description of the FTDI device",
942 .usage
= "description_string",
946 .handler
= &ftdi_handle_channel_command
,
947 .mode
= COMMAND_CONFIG
,
948 .help
= "set the channel of the FTDI device that is used as JTAG",
952 .name
= "layout_init",
953 .handler
= &ftdi_handle_layout_init_command
,
954 .mode
= COMMAND_CONFIG
,
955 .help
= "initialize the FTDI GPIO signals used "
956 "to control output-enables and reset signals",
957 .usage
= "data direction",
960 .name
= "layout_signal",
961 .handler
= &ftdi_handle_layout_signal_command
,
963 .help
= "define a signal controlled by one or more FTDI GPIO as data "
964 "and/or output enable",
965 .usage
= "name [-data mask|-ndata mask] [-oe mask|-noe mask] [-alias|-nalias name]",
968 .name
= "set_signal",
969 .handler
= &ftdi_handle_set_signal_command
,
970 .mode
= COMMAND_EXEC
,
971 .help
= "control a layout-specific signal",
972 .usage
= "name (1|0|z)",
975 .name
= "get_signal",
976 .handler
= &ftdi_handle_get_signal_command
,
977 .mode
= COMMAND_EXEC
,
978 .help
= "read the value of a layout-specific signal",
983 .handler
= &ftdi_handle_vid_pid_command
,
984 .mode
= COMMAND_CONFIG
,
985 .help
= "the vendor ID and product ID of the FTDI device",
986 .usage
= "(vid pid)*",
989 .name
= "tdo_sample_edge",
990 .handler
= &ftdi_handle_tdo_sample_edge_command
,
992 .help
= "set which TCK clock edge is used for sampling TDO "
993 "- default is rising-edge (Setting to falling-edge may "
994 "allow signalling speed increase)",
995 .usage
= "(rising|falling)",
997 COMMAND_REGISTRATION_DONE
1000 static const struct command_registration ftdi_command_handlers
[] = {
1003 .mode
= COMMAND_ANY
,
1004 .help
= "perform ftdi management",
1005 .chain
= ftdi_subcommand_handlers
,
1008 COMMAND_REGISTRATION_DONE
1011 static int create_default_signal(const char *name
, uint16_t data_mask
)
1013 struct signal
*sig
= create_signal(name
);
1015 LOG_ERROR("failed to create signal %s", name
);
1018 sig
->invert_data
= false;
1019 sig
->data_mask
= data_mask
;
1020 sig
->invert_oe
= false;
1026 static int create_signals(void)
1028 if (create_default_signal("TCK", 0x01) != ERROR_OK
)
1030 if (create_default_signal("TDI", 0x02) != ERROR_OK
)
1032 if (create_default_signal("TDO", 0x04) != ERROR_OK
)
1034 if (create_default_signal("TMS", 0x08) != ERROR_OK
)
1039 static int ftdi_swd_init(void)
1041 LOG_INFO("FTDI SWD mode enabled");
1044 if (create_signals() != ERROR_OK
)
1047 swd_cmd_queue_alloced
= 10;
1048 swd_cmd_queue
= malloc(swd_cmd_queue_alloced
* sizeof(*swd_cmd_queue
));
1050 return swd_cmd_queue
? ERROR_OK
: ERROR_FAIL
;
1053 static void ftdi_swd_swdio_en(bool enable
)
1055 struct signal
*oe
= find_signal_by_name("SWDIO_OE");
1058 ftdi_set_signal(oe
, enable
? '1' : '0');
1060 /* Sets TDI/DO pin to input during rx when both pins are connected
1063 direction
|= jtag_direction_init
& 0x0002U
;
1065 direction
&= ~0x0002U
;
1066 mpsse_set_data_bits_low_byte(mpsse_ctx
, output
& 0xff, direction
& 0xff);
1072 * Flush the MPSSE queue and process the SWD transaction queue
1075 static int ftdi_swd_run_queue(void)
1077 LOG_DEBUG_IO("Executing %zu queued transactions", swd_cmd_queue_length
);
1079 struct signal
*led
= find_signal_by_name("LED");
1081 if (queued_retval
!= ERROR_OK
) {
1082 LOG_DEBUG_IO("Skipping due to previous errors: %d", queued_retval
);
1086 /* A transaction must be followed by another transaction or at least 8 idle cycles to
1087 * ensure that data is clocked through the AP. */
1088 mpsse_clock_data_out(mpsse_ctx
, NULL
, 0, 8, SWD_MODE
);
1090 /* Terminate the "blink", if the current layout has that feature */
1092 ftdi_set_signal(led
, '0');
1094 queued_retval
= mpsse_flush(mpsse_ctx
);
1095 if (queued_retval
!= ERROR_OK
) {
1096 LOG_ERROR("MPSSE failed");
1100 for (size_t i
= 0; i
< swd_cmd_queue_length
; i
++) {
1101 int ack
= buf_get_u32(swd_cmd_queue
[i
].trn_ack_data_parity_trn
, 1, 3);
1103 /* Devices do not reply to DP_TARGETSEL write cmd, ignore received ack */
1104 bool check_ack
= swd_cmd_returns_ack(swd_cmd_queue
[i
].cmd
);
1106 LOG_DEBUG_IO("%s%s %s %s reg %X = %08"PRIx32
,
1107 check_ack
? "" : "ack ignored ",
1108 ack
== SWD_ACK_OK
? "OK" : ack
== SWD_ACK_WAIT
? "WAIT" : ack
== SWD_ACK_FAULT
? "FAULT" : "JUNK",
1109 swd_cmd_queue
[i
].cmd
& SWD_CMD_APNDP
? "AP" : "DP",
1110 swd_cmd_queue
[i
].cmd
& SWD_CMD_RNW
? "read" : "write",
1111 (swd_cmd_queue
[i
].cmd
& SWD_CMD_A32
) >> 1,
1112 buf_get_u32(swd_cmd_queue
[i
].trn_ack_data_parity_trn
,
1113 1 + 3 + (swd_cmd_queue
[i
].cmd
& SWD_CMD_RNW
? 0 : 1), 32));
1115 if (ack
!= SWD_ACK_OK
&& check_ack
) {
1116 queued_retval
= swd_ack_to_error_code(ack
);
1119 } else if (swd_cmd_queue
[i
].cmd
& SWD_CMD_RNW
) {
1120 uint32_t data
= buf_get_u32(swd_cmd_queue
[i
].trn_ack_data_parity_trn
, 1 + 3, 32);
1121 int parity
= buf_get_u32(swd_cmd_queue
[i
].trn_ack_data_parity_trn
, 1 + 3 + 32, 1);
1123 if (parity
!= parity_u32(data
)) {
1124 LOG_ERROR("SWD Read data parity mismatch");
1125 queued_retval
= ERROR_FAIL
;
1129 if (swd_cmd_queue
[i
].dst
)
1130 *swd_cmd_queue
[i
].dst
= data
;
1135 swd_cmd_queue_length
= 0;
1136 retval
= queued_retval
;
1137 queued_retval
= ERROR_OK
;
1139 /* Queue a new "blink" */
1140 if (led
&& retval
== ERROR_OK
)
1141 ftdi_set_signal(led
, '1');
1146 static void ftdi_swd_queue_cmd(uint8_t cmd
, uint32_t *dst
, uint32_t data
, uint32_t ap_delay_clk
)
1148 if (swd_cmd_queue_length
>= swd_cmd_queue_alloced
) {
1149 /* Not enough room in the queue. Run the queue and increase its size for next time.
1150 * Note that it's not possible to avoid running the queue here, because mpsse contains
1151 * pointers into the queue which may be invalid after the realloc. */
1152 queued_retval
= ftdi_swd_run_queue();
1153 struct swd_cmd_queue_entry
*q
= realloc(swd_cmd_queue
, swd_cmd_queue_alloced
* 2 * sizeof(*swd_cmd_queue
));
1156 swd_cmd_queue_alloced
*= 2;
1157 LOG_DEBUG("Increased SWD command queue to %zu elements", swd_cmd_queue_alloced
);
1161 if (queued_retval
!= ERROR_OK
)
1164 size_t i
= swd_cmd_queue_length
++;
1165 swd_cmd_queue
[i
].cmd
= cmd
| SWD_CMD_START
| SWD_CMD_PARK
;
1167 mpsse_clock_data_out(mpsse_ctx
, &swd_cmd_queue
[i
].cmd
, 0, 8, SWD_MODE
);
1169 if (swd_cmd_queue
[i
].cmd
& SWD_CMD_RNW
) {
1170 /* Queue a read transaction */
1171 swd_cmd_queue
[i
].dst
= dst
;
1173 ftdi_swd_swdio_en(false);
1174 mpsse_clock_data_in(mpsse_ctx
, swd_cmd_queue
[i
].trn_ack_data_parity_trn
,
1175 0, 1 + 3 + 32 + 1 + 1, SWD_MODE
);
1176 ftdi_swd_swdio_en(true);
1178 /* Queue a write transaction */
1179 ftdi_swd_swdio_en(false);
1181 mpsse_clock_data_in(mpsse_ctx
, swd_cmd_queue
[i
].trn_ack_data_parity_trn
,
1182 0, 1 + 3 + 1, SWD_MODE
);
1184 ftdi_swd_swdio_en(true);
1186 buf_set_u32(swd_cmd_queue
[i
].trn_ack_data_parity_trn
, 1 + 3 + 1, 32, data
);
1187 buf_set_u32(swd_cmd_queue
[i
].trn_ack_data_parity_trn
, 1 + 3 + 1 + 32, 1, parity_u32(data
));
1189 mpsse_clock_data_out(mpsse_ctx
, swd_cmd_queue
[i
].trn_ack_data_parity_trn
,
1190 1 + 3 + 1, 32 + 1, SWD_MODE
);
1193 /* Insert idle cycles after AP accesses to avoid WAIT */
1194 if (cmd
& SWD_CMD_APNDP
)
1195 mpsse_clock_data_out(mpsse_ctx
, NULL
, 0, ap_delay_clk
, SWD_MODE
);
1199 static void ftdi_swd_read_reg(uint8_t cmd
, uint32_t *value
, uint32_t ap_delay_clk
)
1201 assert(cmd
& SWD_CMD_RNW
);
1202 ftdi_swd_queue_cmd(cmd
, value
, 0, ap_delay_clk
);
1205 static void ftdi_swd_write_reg(uint8_t cmd
, uint32_t value
, uint32_t ap_delay_clk
)
1207 assert(!(cmd
& SWD_CMD_RNW
));
1208 ftdi_swd_queue_cmd(cmd
, NULL
, value
, ap_delay_clk
);
1211 static int ftdi_swd_switch_seq(enum swd_special_seq seq
)
1215 LOG_DEBUG("SWD line reset");
1216 ftdi_swd_swdio_en(true);
1217 mpsse_clock_data_out(mpsse_ctx
, swd_seq_line_reset
, 0, swd_seq_line_reset_len
, SWD_MODE
);
1220 LOG_DEBUG("JTAG-to-SWD");
1221 ftdi_swd_swdio_en(true);
1222 mpsse_clock_data_out(mpsse_ctx
, swd_seq_jtag_to_swd
, 0, swd_seq_jtag_to_swd_len
, SWD_MODE
);
1224 case JTAG_TO_DORMANT
:
1225 LOG_DEBUG("JTAG-to-DORMANT");
1226 ftdi_swd_swdio_en(true);
1227 mpsse_clock_data_out(mpsse_ctx
, swd_seq_jtag_to_dormant
, 0, swd_seq_jtag_to_dormant_len
, SWD_MODE
);
1230 LOG_DEBUG("SWD-to-JTAG");
1231 ftdi_swd_swdio_en(true);
1232 mpsse_clock_data_out(mpsse_ctx
, swd_seq_swd_to_jtag
, 0, swd_seq_swd_to_jtag_len
, SWD_MODE
);
1234 case SWD_TO_DORMANT
:
1235 LOG_DEBUG("SWD-to-DORMANT");
1236 ftdi_swd_swdio_en(true);
1237 mpsse_clock_data_out(mpsse_ctx
, swd_seq_swd_to_dormant
, 0, swd_seq_swd_to_dormant_len
, SWD_MODE
);
1239 case DORMANT_TO_SWD
:
1240 LOG_DEBUG("DORMANT-to-SWD");
1241 ftdi_swd_swdio_en(true);
1242 mpsse_clock_data_out(mpsse_ctx
, swd_seq_dormant_to_swd
, 0, swd_seq_dormant_to_swd_len
, SWD_MODE
);
1244 case DORMANT_TO_JTAG
:
1245 LOG_DEBUG("DORMANT-to-JTAG");
1246 ftdi_swd_swdio_en(true);
1247 mpsse_clock_data_out(mpsse_ctx
, swd_seq_dormant_to_jtag
, 0, swd_seq_dormant_to_jtag_len
, SWD_MODE
);
1250 LOG_ERROR("Sequence %d not supported", seq
);
1257 static const struct swd_driver ftdi_swd
= {
1258 .init
= ftdi_swd_init
,
1259 .switch_seq
= ftdi_swd_switch_seq
,
1260 .read_reg
= ftdi_swd_read_reg
,
1261 .write_reg
= ftdi_swd_write_reg
,
1262 .run
= ftdi_swd_run_queue
,
1265 static const char * const ftdi_transports
[] = { "jtag", "swd", NULL
};
1267 static struct jtag_interface ftdi_interface
= {
1268 .supported
= DEBUG_CAP_TMS_SEQ
,
1269 .execute_queue
= ftdi_execute_queue
,
1272 struct adapter_driver ftdi_adapter_driver
= {
1274 .transports
= ftdi_transports
,
1275 .commands
= ftdi_command_handlers
,
1277 .init
= ftdi_initialize
,
1279 .reset
= ftdi_reset
,
1280 .speed
= ftdi_speed
,
1282 .speed_div
= ftdi_speed_div
,
1284 .jtag_ops
= &ftdi_interface
,
1285 .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)