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>
76 #include <transport/transport.h>
77 #include <helper/time_support.h>
85 /* FTDI access library includes */
88 #define JTAG_MODE (LSB_FIRST | POS_EDGE_IN | NEG_EDGE_OUT)
89 #define SWD_MODE (LSB_FIRST | POS_EDGE_IN | NEG_EDGE_OUT)
91 static char *ftdi_device_desc
;
92 static char *ftdi_serial
;
93 static uint8_t ftdi_channel
;
98 /* vid = pid = 0 marks the end of the list */
99 static uint16_t ftdi_vid
[MAX_USB_IDS
+ 1] = { 0 };
100 static uint16_t ftdi_pid
[MAX_USB_IDS
+ 1] = { 0 };
102 static struct mpsse_ctx
*mpsse_ctx
;
113 static struct signal
*signals
;
115 /* FIXME: Where to store per-instance data? We need an SWD context. */
116 static struct swd_cmd_queue_entry
{
119 uint8_t trn_ack_data_parity_trn
[DIV_ROUND_UP(4 + 3 + 32 + 1 + 4, 8)];
121 static size_t swd_cmd_queue_length
;
122 static size_t swd_cmd_queue_alloced
;
123 static int queued_retval
;
126 static uint16_t output
;
127 static uint16_t direction
;
128 static uint16_t jtag_output_init
;
129 static uint16_t jtag_direction_init
;
130 static uint16_t swd_output_init
;
131 static uint16_t swd_direction_init
;
133 static int ftdi_swd_switch_seq(struct adiv5_dap
*dap
, enum swd_special_seq seq
);
135 static struct signal
*find_signal_by_name(const char *name
)
137 for (struct signal
*sig
= signals
; sig
; sig
= sig
->next
) {
138 if (strcmp(name
, sig
->name
) == 0)
144 static struct signal
*create_signal(const char *name
)
146 struct signal
**psig
= &signals
;
148 psig
= &(*psig
)->next
;
150 *psig
= calloc(1, sizeof(**psig
));
154 (*psig
)->name
= strdup(name
);
155 if ((*psig
)->name
== NULL
) {
162 static int ftdi_set_signal(const struct signal
*s
, char value
)
167 if (s
->data_mask
== 0 && s
->oe_mask
== 0) {
168 LOG_ERROR("interface doesn't provide signal '%s'", s
->name
);
173 data
= s
->invert_data
;
177 if (s
->data_mask
== 0) {
178 LOG_ERROR("interface can't drive '%s' high", s
->name
);
181 data
= !s
->invert_data
;
186 if (s
->oe_mask
== 0) {
187 LOG_ERROR("interface can't tri-state '%s'", s
->name
);
190 data
= s
->invert_data
;
194 assert(0 && "invalid signal level specifier");
198 uint16_t old_output
= output
;
199 uint16_t old_direction
= direction
;
201 output
= data
? output
| s
->data_mask
: output
& ~s
->data_mask
;
202 if (s
->oe_mask
== s
->data_mask
)
203 direction
= oe
? direction
| s
->oe_mask
: direction
& ~s
->oe_mask
;
205 output
= oe
? output
| s
->oe_mask
: output
& ~s
->oe_mask
;
207 if ((output
& 0xff) != (old_output
& 0xff) || (direction
& 0xff) != (old_direction
& 0xff))
208 mpsse_set_data_bits_low_byte(mpsse_ctx
, output
& 0xff, direction
& 0xff);
209 if ((output
>> 8 != old_output
>> 8) || (direction
>> 8 != old_direction
>> 8))
210 mpsse_set_data_bits_high_byte(mpsse_ctx
, output
>> 8, direction
>> 8);
217 * Function move_to_state
218 * moves the TAP controller from the current state to a
219 * \a goal_state through a path given by tap_get_tms_path(). State transition
220 * logging is performed by delegation to clock_tms().
222 * @param goal_state is the destination state for the move.
224 static void move_to_state(tap_state_t goal_state
)
226 tap_state_t start_state
= tap_get_state();
228 /* goal_state is 1/2 of a tuple/pair of states which allow convenient
229 lookup of the required TMS pattern to move to this state from the
233 /* do the 2 lookups */
234 uint8_t tms_bits
= tap_get_tms_path(start_state
, goal_state
);
235 int tms_count
= tap_get_tms_path_len(start_state
, goal_state
);
236 assert(tms_count
<= 8);
238 DEBUG_JTAG_IO("start=%s goal=%s", tap_state_name(start_state
), tap_state_name(goal_state
));
240 /* Track state transitions step by step */
241 for (int i
= 0; i
< tms_count
; i
++)
242 tap_set_state(tap_state_transition(tap_get_state(), (tms_bits
>> i
) & 1));
244 mpsse_clock_tms_cs_out(mpsse_ctx
,
252 static int ftdi_speed(int speed
)
255 retval
= mpsse_set_frequency(mpsse_ctx
, speed
);
258 LOG_ERROR("couldn't set FTDI TCK speed");
265 static int ftdi_speed_div(int speed
, int *khz
)
271 static int ftdi_khz(int khz
, int *jtag_speed
)
273 if (khz
== 0 && !mpsse_is_high_speed(mpsse_ctx
)) {
274 LOG_DEBUG("RCLK not supported");
278 *jtag_speed
= khz
* 1000;
282 static void ftdi_end_state(tap_state_t state
)
284 if (tap_is_state_stable(state
))
285 tap_set_end_state(state
);
287 LOG_ERROR("BUG: %s is not a stable end state", tap_state_name(state
));
292 static void ftdi_execute_runtest(struct jtag_command
*cmd
)
297 DEBUG_JTAG_IO("runtest %i cycles, end in %s",
298 cmd
->cmd
.runtest
->num_cycles
,
299 tap_state_name(cmd
->cmd
.runtest
->end_state
));
301 if (tap_get_state() != TAP_IDLE
)
302 move_to_state(TAP_IDLE
);
304 /* TODO: Reuse ftdi_execute_stableclocks */
305 i
= cmd
->cmd
.runtest
->num_cycles
;
307 /* there are no state transitions in this code, so omit state tracking */
308 unsigned this_len
= i
> 7 ? 7 : i
;
309 mpsse_clock_tms_cs_out(mpsse_ctx
, &zero
, 0, this_len
, false, JTAG_MODE
);
313 ftdi_end_state(cmd
->cmd
.runtest
->end_state
);
315 if (tap_get_state() != tap_get_end_state())
316 move_to_state(tap_get_end_state());
318 DEBUG_JTAG_IO("runtest: %i, end in %s",
319 cmd
->cmd
.runtest
->num_cycles
,
320 tap_state_name(tap_get_end_state()));
323 static void ftdi_execute_statemove(struct jtag_command
*cmd
)
325 DEBUG_JTAG_IO("statemove end in %s",
326 tap_state_name(cmd
->cmd
.statemove
->end_state
));
328 ftdi_end_state(cmd
->cmd
.statemove
->end_state
);
330 /* shortest-path move to desired end state */
331 if (tap_get_state() != tap_get_end_state() || tap_get_end_state() == TAP_RESET
)
332 move_to_state(tap_get_end_state());
336 * Clock a bunch of TMS (or SWDIO) transitions, to change the JTAG
337 * (or SWD) state machine. REVISIT: Not the best method, perhaps.
339 static void ftdi_execute_tms(struct jtag_command
*cmd
)
341 DEBUG_JTAG_IO("TMS: %d bits", cmd
->cmd
.tms
->num_bits
);
343 /* TODO: Missing tap state tracking, also missing from ft2232.c! */
344 mpsse_clock_tms_cs_out(mpsse_ctx
,
347 cmd
->cmd
.tms
->num_bits
,
352 static void ftdi_execute_pathmove(struct jtag_command
*cmd
)
354 tap_state_t
*path
= cmd
->cmd
.pathmove
->path
;
355 int num_states
= cmd
->cmd
.pathmove
->num_states
;
357 DEBUG_JTAG_IO("pathmove: %i states, current: %s end: %s", num_states
,
358 tap_state_name(tap_get_state()),
359 tap_state_name(path
[num_states
-1]));
362 unsigned bit_count
= 0;
363 uint8_t tms_byte
= 0;
367 /* this loop verifies that the path is legal and logs each state in the path */
368 while (num_states
--) {
370 /* either TMS=0 or TMS=1 must work ... */
371 if (tap_state_transition(tap_get_state(), false)
372 == path
[state_count
])
373 buf_set_u32(&tms_byte
, bit_count
++, 1, 0x0);
374 else if (tap_state_transition(tap_get_state(), true)
375 == path
[state_count
]) {
376 buf_set_u32(&tms_byte
, bit_count
++, 1, 0x1);
378 /* ... or else the caller goofed BADLY */
380 LOG_ERROR("BUG: %s -> %s isn't a valid "
381 "TAP state transition",
382 tap_state_name(tap_get_state()),
383 tap_state_name(path
[state_count
]));
387 tap_set_state(path
[state_count
]);
390 if (bit_count
== 7 || num_states
== 0) {
391 mpsse_clock_tms_cs_out(mpsse_ctx
,
400 tap_set_end_state(tap_get_state());
403 static void ftdi_execute_scan(struct jtag_command
*cmd
)
405 DEBUG_JTAG_IO("%s type:%d", cmd
->cmd
.scan
->ir_scan
? "IRSCAN" : "DRSCAN",
406 jtag_scan_type(cmd
->cmd
.scan
));
408 /* Make sure there are no trailing fields with num_bits == 0, or the logic below will fail. */
409 while (cmd
->cmd
.scan
->num_fields
> 0
410 && cmd
->cmd
.scan
->fields
[cmd
->cmd
.scan
->num_fields
- 1].num_bits
== 0) {
411 cmd
->cmd
.scan
->num_fields
--;
412 LOG_DEBUG("discarding trailing empty field");
415 if (cmd
->cmd
.scan
->num_fields
== 0) {
416 LOG_DEBUG("empty scan, doing nothing");
420 if (cmd
->cmd
.scan
->ir_scan
) {
421 if (tap_get_state() != TAP_IRSHIFT
)
422 move_to_state(TAP_IRSHIFT
);
424 if (tap_get_state() != TAP_DRSHIFT
)
425 move_to_state(TAP_DRSHIFT
);
428 ftdi_end_state(cmd
->cmd
.scan
->end_state
);
430 struct scan_field
*field
= cmd
->cmd
.scan
->fields
;
431 unsigned scan_size
= 0;
433 for (int i
= 0; i
< cmd
->cmd
.scan
->num_fields
; i
++, field
++) {
434 scan_size
+= field
->num_bits
;
435 DEBUG_JTAG_IO("%s%s field %d/%d %d bits",
436 field
->in_value
? "in" : "",
437 field
->out_value
? "out" : "",
439 cmd
->cmd
.scan
->num_fields
,
442 if (i
== cmd
->cmd
.scan
->num_fields
- 1 && tap_get_state() != tap_get_end_state()) {
443 /* Last field, and we're leaving IRSHIFT/DRSHIFT. Clock last bit during tap
444 * movement. This last field can't have length zero, it was checked above. */
445 mpsse_clock_data(mpsse_ctx
,
452 uint8_t last_bit
= 0;
453 if (field
->out_value
)
454 bit_copy(&last_bit
, 0, field
->out_value
, field
->num_bits
- 1, 1);
455 uint8_t tms_bits
= 0x01;
456 mpsse_clock_tms_cs(mpsse_ctx
,
464 tap_set_state(tap_state_transition(tap_get_state(), 1));
465 mpsse_clock_tms_cs_out(mpsse_ctx
,
471 tap_set_state(tap_state_transition(tap_get_state(), 0));
473 mpsse_clock_data(mpsse_ctx
,
482 if (tap_get_state() != tap_get_end_state())
483 move_to_state(tap_get_end_state());
485 DEBUG_JTAG_IO("%s scan, %i bits, end in %s",
486 (cmd
->cmd
.scan
->ir_scan
) ? "IR" : "DR", scan_size
,
487 tap_state_name(tap_get_end_state()));
490 static void ftdi_execute_reset(struct jtag_command
*cmd
)
492 DEBUG_JTAG_IO("reset trst: %i srst %i",
493 cmd
->cmd
.reset
->trst
, cmd
->cmd
.reset
->srst
);
495 if (cmd
->cmd
.reset
->trst
== 1
496 || (cmd
->cmd
.reset
->srst
497 && (jtag_get_reset_config() & RESET_SRST_PULLS_TRST
)))
498 tap_set_state(TAP_RESET
);
500 struct signal
*trst
= find_signal_by_name("nTRST");
501 if (cmd
->cmd
.reset
->trst
== 1) {
503 ftdi_set_signal(trst
, '0');
505 LOG_ERROR("Can't assert TRST: nTRST signal is not defined");
506 } else if (trst
&& cmd
->cmd
.reset
->trst
== 0) {
507 if (jtag_get_reset_config() & RESET_TRST_OPEN_DRAIN
)
508 ftdi_set_signal(trst
, 'z');
510 ftdi_set_signal(trst
, '1');
513 struct signal
*srst
= find_signal_by_name("nSRST");
514 if (cmd
->cmd
.reset
->srst
== 1) {
516 ftdi_set_signal(srst
, '0');
518 LOG_ERROR("Can't assert SRST: nSRST signal is not defined");
519 } else if (srst
&& cmd
->cmd
.reset
->srst
== 0) {
520 if (jtag_get_reset_config() & RESET_SRST_PUSH_PULL
)
521 ftdi_set_signal(srst
, '1');
523 ftdi_set_signal(srst
, 'z');
526 DEBUG_JTAG_IO("trst: %i, srst: %i",
527 cmd
->cmd
.reset
->trst
, cmd
->cmd
.reset
->srst
);
530 static void ftdi_execute_sleep(struct jtag_command
*cmd
)
532 DEBUG_JTAG_IO("sleep %" PRIi32
, cmd
->cmd
.sleep
->us
);
534 mpsse_flush(mpsse_ctx
);
535 jtag_sleep(cmd
->cmd
.sleep
->us
);
536 DEBUG_JTAG_IO("sleep %" PRIi32
" usec while in %s",
538 tap_state_name(tap_get_state()));
541 static void ftdi_execute_stableclocks(struct jtag_command
*cmd
)
543 /* this is only allowed while in a stable state. A check for a stable
544 * state was done in jtag_add_clocks()
546 int num_cycles
= cmd
->cmd
.stableclocks
->num_cycles
;
548 /* 7 bits of either ones or zeros. */
549 uint8_t tms
= tap_get_state() == TAP_RESET
? 0x7f : 0x00;
551 /* TODO: Use mpsse_clock_data with in=out=0 for this, if TMS can be set to
552 * the correct level and remain there during the scan */
553 while (num_cycles
> 0) {
554 /* there are no state transitions in this code, so omit state tracking */
555 unsigned this_len
= num_cycles
> 7 ? 7 : num_cycles
;
556 mpsse_clock_tms_cs_out(mpsse_ctx
, &tms
, 0, this_len
, false, JTAG_MODE
);
557 num_cycles
-= this_len
;
560 DEBUG_JTAG_IO("clocks %i while in %s",
561 cmd
->cmd
.stableclocks
->num_cycles
,
562 tap_state_name(tap_get_state()));
565 static void ftdi_execute_command(struct jtag_command
*cmd
)
569 ftdi_execute_reset(cmd
);
572 ftdi_execute_runtest(cmd
);
575 ftdi_execute_statemove(cmd
);
578 ftdi_execute_pathmove(cmd
);
581 ftdi_execute_scan(cmd
);
584 ftdi_execute_sleep(cmd
);
586 case JTAG_STABLECLOCKS
:
587 ftdi_execute_stableclocks(cmd
);
590 ftdi_execute_tms(cmd
);
593 LOG_ERROR("BUG: unknown JTAG command type encountered: %d", cmd
->type
);
598 static int ftdi_execute_queue(void)
600 /* blink, if the current layout has that feature */
601 struct signal
*led
= find_signal_by_name("LED");
603 ftdi_set_signal(led
, '1');
605 for (struct jtag_command
*cmd
= jtag_command_queue
; cmd
; cmd
= cmd
->next
) {
606 /* fill the write buffer with the desired command */
607 ftdi_execute_command(cmd
);
611 ftdi_set_signal(led
, '0');
613 int retval
= mpsse_flush(mpsse_ctx
);
614 if (retval
!= ERROR_OK
)
615 LOG_ERROR("error while flushing MPSSE queue: %d", retval
);
620 static int ftdi_initialize(void)
622 if (tap_get_tms_path_len(TAP_IRPAUSE
, TAP_IRPAUSE
) == 7)
623 LOG_DEBUG("ftdi interface using 7 step jtag state transitions");
625 LOG_DEBUG("ftdi interface using shortest path jtag state transitions");
627 for (int i
= 0; ftdi_vid
[i
] || ftdi_pid
[i
]; i
++) {
628 mpsse_ctx
= mpsse_open(&ftdi_vid
[i
], &ftdi_pid
[i
], ftdi_device_desc
,
629 ftdi_serial
, ftdi_channel
);
635 return ERROR_JTAG_INIT_FAILED
;
637 output
= swd_mode
? swd_output_init
: jtag_output_init
;
638 direction
= swd_mode
? swd_direction_init
: jtag_direction_init
;
640 mpsse_set_data_bits_low_byte(mpsse_ctx
, output
& 0xff, direction
& 0xff);
641 mpsse_set_data_bits_high_byte(mpsse_ctx
, output
>> 8, direction
>> 8);
643 mpsse_loopback_config(mpsse_ctx
, false);
645 /* Set a low default */
646 freq
= mpsse_set_frequency(mpsse_ctx
, 1000);
649 ftdi_swd_switch_seq(NULL
, JTAG_TO_SWD
);
651 ftdi_swd_switch_seq(NULL
, SWD_TO_JTAG
);
653 return mpsse_flush(mpsse_ctx
);
656 static int ftdi_quit(void)
658 mpsse_close(mpsse_ctx
);
663 COMMAND_HANDLER(ftdi_handle_device_desc_command
)
666 if (ftdi_device_desc
)
667 free(ftdi_device_desc
);
668 ftdi_device_desc
= strdup(CMD_ARGV
[0]);
670 LOG_ERROR("expected exactly one argument to ftdi_device_desc <description>");
676 COMMAND_HANDLER(ftdi_handle_serial_command
)
681 ftdi_serial
= strdup(CMD_ARGV
[0]);
683 return ERROR_COMMAND_SYNTAX_ERROR
;
689 COMMAND_HANDLER(ftdi_handle_channel_command
)
692 COMMAND_PARSE_NUMBER(u8
, CMD_ARGV
[0], ftdi_channel
);
694 return ERROR_COMMAND_SYNTAX_ERROR
;
699 COMMAND_HANDLER(ftdi_handle_layout_init_command
)
702 return ERROR_COMMAND_SYNTAX_ERROR
;
704 COMMAND_PARSE_NUMBER(u16
, CMD_ARGV
[0], jtag_output_init
);
705 COMMAND_PARSE_NUMBER(u16
, CMD_ARGV
[1], jtag_direction_init
);
710 COMMAND_HANDLER(ftdi_handle_layout_init_swd_command
)
713 return ERROR_COMMAND_SYNTAX_ERROR
;
715 COMMAND_PARSE_NUMBER(u16
, CMD_ARGV
[0], swd_output_init
);
716 COMMAND_PARSE_NUMBER(u16
, CMD_ARGV
[1], swd_direction_init
);
721 COMMAND_HANDLER(ftdi_handle_layout_signal_command
)
724 return ERROR_COMMAND_SYNTAX_ERROR
;
726 bool invert_data
= false;
727 uint16_t data_mask
= 0;
728 bool invert_oe
= false;
729 uint16_t oe_mask
= 0;
730 for (unsigned i
= 1; i
< CMD_ARGC
; i
+= 2) {
731 if (strcmp("-data", CMD_ARGV
[i
]) == 0) {
733 COMMAND_PARSE_NUMBER(u16
, CMD_ARGV
[i
+ 1], data_mask
);
734 } else if (strcmp("-ndata", CMD_ARGV
[i
]) == 0) {
736 COMMAND_PARSE_NUMBER(u16
, CMD_ARGV
[i
+ 1], data_mask
);
737 } else if (strcmp("-oe", CMD_ARGV
[i
]) == 0) {
739 COMMAND_PARSE_NUMBER(u16
, CMD_ARGV
[i
+ 1], oe_mask
);
740 } else if (strcmp("-noe", CMD_ARGV
[i
]) == 0) {
742 COMMAND_PARSE_NUMBER(u16
, CMD_ARGV
[i
+ 1], oe_mask
);
743 } else if (!strcmp("-alias", CMD_ARGV
[i
]) ||
744 !strcmp("-nalias", CMD_ARGV
[i
])) {
745 if (!strcmp("-nalias", CMD_ARGV
[i
]))
747 struct signal
*sig
= find_signal_by_name(CMD_ARGV
[i
+ 1]);
749 LOG_ERROR("signal %s is not defined", CMD_ARGV
[i
+ 1]);
752 data_mask
= sig
->data_mask
;
753 oe_mask
= sig
->oe_mask
;
754 invert_oe
= sig
->invert_oe
;
755 invert_data
^= sig
->invert_data
;
757 LOG_ERROR("unknown option '%s'", CMD_ARGV
[i
]);
758 return ERROR_COMMAND_SYNTAX_ERROR
;
763 sig
= find_signal_by_name(CMD_ARGV
[0]);
765 sig
= create_signal(CMD_ARGV
[0]);
767 LOG_ERROR("failed to create signal %s", CMD_ARGV
[0]);
771 sig
->invert_data
= invert_data
;
772 sig
->data_mask
= data_mask
;
773 sig
->invert_oe
= invert_oe
;
774 sig
->oe_mask
= oe_mask
;
779 COMMAND_HANDLER(ftdi_handle_set_signal_command
)
782 return ERROR_COMMAND_SYNTAX_ERROR
;
785 sig
= find_signal_by_name(CMD_ARGV
[0]);
787 LOG_ERROR("interface configuration doesn't define signal '%s'", CMD_ARGV
[0]);
791 switch (*CMD_ARGV
[1]) {
796 /* single character level specifier only */
797 if (CMD_ARGV
[1][1] == '\0') {
798 ftdi_set_signal(sig
, *CMD_ARGV
[1]);
802 LOG_ERROR("unknown signal level '%s', use 0, 1 or z", CMD_ARGV
[1]);
803 return ERROR_COMMAND_SYNTAX_ERROR
;
806 return mpsse_flush(mpsse_ctx
);
809 COMMAND_HANDLER(ftdi_handle_vid_pid_command
)
811 if (CMD_ARGC
> MAX_USB_IDS
* 2) {
812 LOG_WARNING("ignoring extra IDs in ftdi_vid_pid "
813 "(maximum is %d pairs)", MAX_USB_IDS
);
814 CMD_ARGC
= MAX_USB_IDS
* 2;
816 if (CMD_ARGC
< 2 || (CMD_ARGC
& 1)) {
817 LOG_WARNING("incomplete ftdi_vid_pid configuration directive");
819 return ERROR_COMMAND_SYNTAX_ERROR
;
820 /* remove the incomplete trailing id */
825 for (i
= 0; i
< CMD_ARGC
; i
+= 2) {
826 COMMAND_PARSE_NUMBER(u16
, CMD_ARGV
[i
], ftdi_vid
[i
>> 1]);
827 COMMAND_PARSE_NUMBER(u16
, CMD_ARGV
[i
+ 1], ftdi_pid
[i
>> 1]);
831 * Explicitly terminate, in case there are multiples instances of
834 ftdi_vid
[i
>> 1] = ftdi_pid
[i
>> 1] = 0;
839 static const struct command_registration ftdi_command_handlers
[] = {
841 .name
= "ftdi_device_desc",
842 .handler
= &ftdi_handle_device_desc_command
,
843 .mode
= COMMAND_CONFIG
,
844 .help
= "set the USB device description of the FTDI device",
845 .usage
= "description_string",
848 .name
= "ftdi_serial",
849 .handler
= &ftdi_handle_serial_command
,
850 .mode
= COMMAND_CONFIG
,
851 .help
= "set the serial number of the FTDI device",
852 .usage
= "serial_string",
855 .name
= "ftdi_channel",
856 .handler
= &ftdi_handle_channel_command
,
857 .mode
= COMMAND_CONFIG
,
858 .help
= "set the channel of the FTDI device that is used as JTAG",
862 .name
= "ftdi_layout_init",
863 .handler
= &ftdi_handle_layout_init_command
,
864 .mode
= COMMAND_CONFIG
,
865 .help
= "initialize the FTDI GPIO signals used "
866 "to control output-enables and reset signals"
867 "when JTAG mode is selected",
868 .usage
= "data direction",
871 .name
= "ftdi_layout_init_swd",
872 .handler
= &ftdi_handle_layout_init_swd_command
,
873 .mode
= COMMAND_CONFIG
,
874 .help
= "initialize the FTDI GPIO signals used "
875 "to control output-enables and reset signals"
876 "when SWD mode is selected",
877 .usage
= "data direction",
880 .name
= "ftdi_layout_signal",
881 .handler
= &ftdi_handle_layout_signal_command
,
883 .help
= "define a signal controlled by one or more FTDI GPIO as data "
884 "and/or output enable",
885 .usage
= "name [-data mask|-ndata mask] [-oe mask|-noe mask] [-alias|-nalias name]",
888 .name
= "ftdi_set_signal",
889 .handler
= &ftdi_handle_set_signal_command
,
890 .mode
= COMMAND_EXEC
,
891 .help
= "control a layout-specific signal",
892 .usage
= "name (1|0|z)",
895 .name
= "ftdi_vid_pid",
896 .handler
= &ftdi_handle_vid_pid_command
,
897 .mode
= COMMAND_CONFIG
,
898 .help
= "the vendor ID and product ID of the FTDI device",
899 .usage
= "(vid pid)* ",
901 COMMAND_REGISTRATION_DONE
904 static int ftdi_swd_init(void)
906 LOG_INFO("FTDI SWD mode enabled");
909 swd_cmd_queue_alloced
= 10;
910 swd_cmd_queue
= malloc(swd_cmd_queue_alloced
* sizeof(*swd_cmd_queue
));
912 return swd_cmd_queue
!= NULL
? ERROR_OK
: ERROR_FAIL
;
915 static void ftdi_swd_swdio_en(bool enable
)
917 struct signal
*oe
= find_signal_by_name("SWDIO_OE");
919 ftdi_set_signal(oe
, enable
? '1' : '0');
923 * Flush the MPSSE queue and process the SWD transaction queue
927 static int ftdi_swd_run_queue(struct adiv5_dap
*dap
)
929 LOG_DEBUG("Executing %zu queued transactions", swd_cmd_queue_length
);
931 struct signal
*led
= find_signal_by_name("LED");
933 if (queued_retval
!= ERROR_OK
) {
934 LOG_DEBUG("Skipping due to previous errors: %d", queued_retval
);
938 /* A transaction must be followed by another transaction or at least 8 idle cycles to
939 * ensure that data is clocked through the AP. */
940 mpsse_clock_data_out(mpsse_ctx
, NULL
, 0, 8, SWD_MODE
);
942 /* Terminate the "blink", if the current layout has that feature */
944 ftdi_set_signal(led
, '0');
946 queued_retval
= mpsse_flush(mpsse_ctx
);
947 if (queued_retval
!= ERROR_OK
) {
948 LOG_ERROR("MPSSE failed");
952 for (size_t i
= 0; i
< swd_cmd_queue_length
; i
++) {
953 int ack
= buf_get_u32(&swd_cmd_queue
[i
].trn_ack_data_parity_trn
, 1, 3);
955 LOG_DEBUG("%s %s %s reg %X = %08"PRIx32
,
956 ack
== SWD_ACK_OK
? "OK" : ack
== SWD_ACK_WAIT
? "WAIT" : ack
== SWD_ACK_FAULT
? "FAULT" : "JUNK",
957 swd_cmd_queue
[i
].cmd
& SWD_CMD_APnDP
? "AP" : "DP",
958 swd_cmd_queue
[i
].cmd
& SWD_CMD_RnW
? "read" : "write",
959 (swd_cmd_queue
[i
].cmd
& SWD_CMD_A32
) >> 1,
960 buf_get_u32(swd_cmd_queue
[i
].trn_ack_data_parity_trn
,
961 1 + 3 + (swd_cmd_queue
[i
].cmd
& SWD_CMD_RnW
? 0 : 1), 32));
963 if (ack
!= SWD_ACK_OK
) {
967 } else if (swd_cmd_queue
[i
].cmd
& SWD_CMD_RnW
) {
968 uint32_t data
= buf_get_u32(swd_cmd_queue
[i
].trn_ack_data_parity_trn
, 1 + 3, 32);
969 int parity
= buf_get_u32(swd_cmd_queue
[i
].trn_ack_data_parity_trn
, 1 + 3 + 32, 1);
971 if (parity
!= parity_u32(data
)) {
972 LOG_ERROR("SWD Read data parity mismatch");
973 queued_retval
= ERROR_FAIL
;
977 if (swd_cmd_queue
[i
].dst
!= NULL
)
978 *swd_cmd_queue
[i
].dst
= data
;
983 swd_cmd_queue_length
= 0;
984 retval
= queued_retval
;
985 queued_retval
= ERROR_OK
;
987 /* Queue a new "blink" */
988 if (led
&& retval
== ERROR_OK
)
989 ftdi_set_signal(led
, '1');
994 static void ftdi_swd_queue_cmd(struct adiv5_dap
*dap
, uint8_t cmd
, uint32_t *dst
, uint32_t data
)
996 if (swd_cmd_queue_length
>= swd_cmd_queue_alloced
) {
997 /* Not enough room in the queue. Run the queue and increase its size for next time.
998 * Note that it's not possible to avoid running the queue here, because mpsse contains
999 * pointers into the queue which may be invalid after the realloc. */
1000 queued_retval
= ftdi_swd_run_queue(dap
);
1001 struct swd_cmd_queue_entry
*q
= realloc(swd_cmd_queue
, swd_cmd_queue_alloced
* 2 * sizeof(*swd_cmd_queue
));
1004 swd_cmd_queue_alloced
*= 2;
1005 LOG_DEBUG("Increased SWD command queue to %zu elements", swd_cmd_queue_alloced
);
1009 if (queued_retval
!= ERROR_OK
)
1012 size_t i
= swd_cmd_queue_length
++;
1013 swd_cmd_queue
[i
].cmd
= cmd
| SWD_CMD_START
| SWD_CMD_PARK
;
1015 mpsse_clock_data_out(mpsse_ctx
, &swd_cmd_queue
[i
].cmd
, 0, 8, SWD_MODE
);
1017 if (swd_cmd_queue
[i
].cmd
& SWD_CMD_RnW
) {
1018 /* Queue a read transaction */
1019 swd_cmd_queue
[i
].dst
= dst
;
1021 ftdi_swd_swdio_en(false);
1022 mpsse_clock_data_in(mpsse_ctx
, swd_cmd_queue
[i
].trn_ack_data_parity_trn
,
1023 0, 1 + 3 + 32 + 1 + 1, SWD_MODE
);
1024 ftdi_swd_swdio_en(true);
1026 /* Queue a write transaction */
1027 ftdi_swd_swdio_en(false);
1029 mpsse_clock_data_in(mpsse_ctx
, swd_cmd_queue
[i
].trn_ack_data_parity_trn
,
1030 0, 1 + 3 + 1, SWD_MODE
);
1032 ftdi_swd_swdio_en(true);
1034 buf_set_u32(swd_cmd_queue
[i
].trn_ack_data_parity_trn
, 1 + 3 + 1, 32, data
);
1035 buf_set_u32(swd_cmd_queue
[i
].trn_ack_data_parity_trn
, 1 + 3 + 1 + 32, 1, parity_u32(data
));
1037 mpsse_clock_data_out(mpsse_ctx
, swd_cmd_queue
[i
].trn_ack_data_parity_trn
,
1038 1 + 3 + 1, 32 + 1, SWD_MODE
);
1041 /* Insert idle cycles after AP accesses to avoid WAIT */
1042 if (cmd
& SWD_CMD_APnDP
)
1043 mpsse_clock_data_out(mpsse_ctx
, NULL
, 0, dap
->memaccess_tck
, SWD_MODE
);
1047 static void ftdi_swd_read_reg(struct adiv5_dap
*dap
, uint8_t cmd
, uint32_t *value
)
1049 assert(cmd
& SWD_CMD_RnW
);
1050 ftdi_swd_queue_cmd(dap
, cmd
, value
, 0);
1053 static void ftdi_swd_write_reg(struct adiv5_dap
*dap
, uint8_t cmd
, uint32_t value
)
1055 assert(!(cmd
& SWD_CMD_RnW
));
1056 ftdi_swd_queue_cmd(dap
, cmd
, NULL
, value
);
1059 static int_least32_t ftdi_swd_frequency(struct adiv5_dap
*dap
, int_least32_t hz
)
1062 freq
= mpsse_set_frequency(mpsse_ctx
, hz
);
1067 static int ftdi_swd_switch_seq(struct adiv5_dap
*dap
, enum swd_special_seq seq
)
1071 LOG_DEBUG("SWD line reset");
1072 mpsse_clock_data_out(mpsse_ctx
, swd_seq_line_reset
, 0, swd_seq_line_reset_len
, SWD_MODE
);
1075 LOG_DEBUG("JTAG-to-SWD");
1076 mpsse_clock_data_out(mpsse_ctx
, swd_seq_jtag_to_swd
, 0, swd_seq_jtag_to_swd_len
, SWD_MODE
);
1079 LOG_DEBUG("SWD-to-JTAG");
1080 mpsse_clock_data_out(mpsse_ctx
, swd_seq_swd_to_jtag
, 0, swd_seq_swd_to_jtag_len
, SWD_MODE
);
1083 LOG_ERROR("Sequence %d not supported", seq
);
1090 static const struct swd_driver ftdi_swd
= {
1091 .init
= ftdi_swd_init
,
1092 .frequency
= ftdi_swd_frequency
,
1093 .switch_seq
= ftdi_swd_switch_seq
,
1094 .read_reg
= ftdi_swd_read_reg
,
1095 .write_reg
= ftdi_swd_write_reg
,
1096 .run
= ftdi_swd_run_queue
,
1099 static const char * const ftdi_transports
[] = { "jtag", "swd", NULL
};
1101 struct jtag_interface ftdi_interface
= {
1103 .supported
= DEBUG_CAP_TMS_SEQ
,
1104 .commands
= ftdi_command_handlers
,
1105 .transports
= ftdi_transports
,
1108 .init
= ftdi_initialize
,
1110 .speed
= ftdi_speed
,
1111 .speed_div
= ftdi_speed_div
,
1113 .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)