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 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 char *ftdi_serial
;
94 static char *ftdi_location
;
95 static uint8_t ftdi_channel
;
96 static uint8_t ftdi_jtag_mode
= JTAG_MODE
;
100 #define MAX_USB_IDS 8
101 /* vid = pid = 0 marks the end of the list */
102 static uint16_t ftdi_vid
[MAX_USB_IDS
+ 1] = { 0 };
103 static uint16_t ftdi_pid
[MAX_USB_IDS
+ 1] = { 0 };
105 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
== NULL
) {
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);
218 * Function move_to_state
219 * moves the TAP controller from the current state to a
220 * \a goal_state through a path given by tap_get_tms_path(). State transition
221 * logging is performed by delegation to clock_tms().
223 * @param goal_state is the destination state for the move.
225 static void move_to_state(tap_state_t goal_state
)
227 tap_state_t start_state
= tap_get_state();
229 /* goal_state is 1/2 of a tuple/pair of states which allow convenient
230 lookup of the required TMS pattern to move to this state from the
234 /* do the 2 lookups */
235 uint8_t tms_bits
= tap_get_tms_path(start_state
, goal_state
);
236 int tms_count
= tap_get_tms_path_len(start_state
, goal_state
);
237 assert(tms_count
<= 8);
239 DEBUG_JTAG_IO("start=%s goal=%s", tap_state_name(start_state
), tap_state_name(goal_state
));
241 /* Track state transitions step by step */
242 for (int i
= 0; i
< tms_count
; i
++)
243 tap_set_state(tap_state_transition(tap_get_state(), (tms_bits
>> i
) & 1));
245 mpsse_clock_tms_cs_out(mpsse_ctx
,
253 static int ftdi_speed(int speed
)
256 retval
= mpsse_set_frequency(mpsse_ctx
, speed
);
259 LOG_ERROR("couldn't set FTDI TCK speed");
263 if (!swd_mode
&& speed
>= 10000000 && ftdi_jtag_mode
!= JTAG_MODE_ALT
)
264 LOG_INFO("ftdi: if you experience problems at higher adapter clocks, try "
265 "the command \"ftdi_tdo_sample_edge falling\"");
269 static int ftdi_speed_div(int speed
, int *khz
)
275 static int ftdi_khz(int khz
, int *jtag_speed
)
277 if (khz
== 0 && !mpsse_is_high_speed(mpsse_ctx
)) {
278 LOG_DEBUG("RCLK not supported");
282 *jtag_speed
= khz
* 1000;
286 static void ftdi_end_state(tap_state_t state
)
288 if (tap_is_state_stable(state
))
289 tap_set_end_state(state
);
291 LOG_ERROR("BUG: %s is not a stable end state", tap_state_name(state
));
296 static void ftdi_execute_runtest(struct jtag_command
*cmd
)
301 DEBUG_JTAG_IO("runtest %i cycles, end in %s",
302 cmd
->cmd
.runtest
->num_cycles
,
303 tap_state_name(cmd
->cmd
.runtest
->end_state
));
305 if (tap_get_state() != TAP_IDLE
)
306 move_to_state(TAP_IDLE
);
308 /* TODO: Reuse ftdi_execute_stableclocks */
309 i
= cmd
->cmd
.runtest
->num_cycles
;
311 /* there are no state transitions in this code, so omit state tracking */
312 unsigned this_len
= i
> 7 ? 7 : i
;
313 mpsse_clock_tms_cs_out(mpsse_ctx
, &zero
, 0, this_len
, false, ftdi_jtag_mode
);
317 ftdi_end_state(cmd
->cmd
.runtest
->end_state
);
319 if (tap_get_state() != tap_get_end_state())
320 move_to_state(tap_get_end_state());
322 DEBUG_JTAG_IO("runtest: %i, end in %s",
323 cmd
->cmd
.runtest
->num_cycles
,
324 tap_state_name(tap_get_end_state()));
327 static void ftdi_execute_statemove(struct jtag_command
*cmd
)
329 DEBUG_JTAG_IO("statemove end in %s",
330 tap_state_name(cmd
->cmd
.statemove
->end_state
));
332 ftdi_end_state(cmd
->cmd
.statemove
->end_state
);
334 /* shortest-path move to desired end state */
335 if (tap_get_state() != tap_get_end_state() || tap_get_end_state() == TAP_RESET
)
336 move_to_state(tap_get_end_state());
340 * Clock a bunch of TMS (or SWDIO) transitions, to change the JTAG
341 * (or SWD) state machine. REVISIT: Not the best method, perhaps.
343 static void ftdi_execute_tms(struct jtag_command
*cmd
)
345 DEBUG_JTAG_IO("TMS: %d bits", cmd
->cmd
.tms
->num_bits
);
347 /* TODO: Missing tap state tracking, also missing from ft2232.c! */
348 mpsse_clock_tms_cs_out(mpsse_ctx
,
351 cmd
->cmd
.tms
->num_bits
,
356 static void ftdi_execute_pathmove(struct jtag_command
*cmd
)
358 tap_state_t
*path
= cmd
->cmd
.pathmove
->path
;
359 int num_states
= cmd
->cmd
.pathmove
->num_states
;
361 DEBUG_JTAG_IO("pathmove: %i states, current: %s end: %s", num_states
,
362 tap_state_name(tap_get_state()),
363 tap_state_name(path
[num_states
-1]));
366 unsigned bit_count
= 0;
367 uint8_t tms_byte
= 0;
371 /* this loop verifies that the path is legal and logs each state in the path */
372 while (num_states
--) {
374 /* either TMS=0 or TMS=1 must work ... */
375 if (tap_state_transition(tap_get_state(), false)
376 == path
[state_count
])
377 buf_set_u32(&tms_byte
, bit_count
++, 1, 0x0);
378 else if (tap_state_transition(tap_get_state(), true)
379 == path
[state_count
]) {
380 buf_set_u32(&tms_byte
, bit_count
++, 1, 0x1);
382 /* ... or else the caller goofed BADLY */
384 LOG_ERROR("BUG: %s -> %s isn't a valid "
385 "TAP state transition",
386 tap_state_name(tap_get_state()),
387 tap_state_name(path
[state_count
]));
391 tap_set_state(path
[state_count
]);
394 if (bit_count
== 7 || num_states
== 0) {
395 mpsse_clock_tms_cs_out(mpsse_ctx
,
404 tap_set_end_state(tap_get_state());
407 static void ftdi_execute_scan(struct jtag_command
*cmd
)
409 DEBUG_JTAG_IO("%s type:%d", cmd
->cmd
.scan
->ir_scan
? "IRSCAN" : "DRSCAN",
410 jtag_scan_type(cmd
->cmd
.scan
));
412 /* Make sure there are no trailing fields with num_bits == 0, or the logic below will fail. */
413 while (cmd
->cmd
.scan
->num_fields
> 0
414 && cmd
->cmd
.scan
->fields
[cmd
->cmd
.scan
->num_fields
- 1].num_bits
== 0) {
415 cmd
->cmd
.scan
->num_fields
--;
416 LOG_DEBUG("discarding trailing empty field");
419 if (cmd
->cmd
.scan
->num_fields
== 0) {
420 LOG_DEBUG("empty scan, doing nothing");
424 if (cmd
->cmd
.scan
->ir_scan
) {
425 if (tap_get_state() != TAP_IRSHIFT
)
426 move_to_state(TAP_IRSHIFT
);
428 if (tap_get_state() != TAP_DRSHIFT
)
429 move_to_state(TAP_DRSHIFT
);
432 ftdi_end_state(cmd
->cmd
.scan
->end_state
);
434 struct scan_field
*field
= cmd
->cmd
.scan
->fields
;
435 unsigned scan_size
= 0;
437 for (int i
= 0; i
< cmd
->cmd
.scan
->num_fields
; i
++, field
++) {
438 scan_size
+= field
->num_bits
;
439 DEBUG_JTAG_IO("%s%s field %d/%d %d bits",
440 field
->in_value
? "in" : "",
441 field
->out_value
? "out" : "",
443 cmd
->cmd
.scan
->num_fields
,
446 if (i
== cmd
->cmd
.scan
->num_fields
- 1 && tap_get_state() != tap_get_end_state()) {
447 /* Last field, and we're leaving IRSHIFT/DRSHIFT. Clock last bit during tap
448 * movement. This last field can't have length zero, it was checked above. */
449 mpsse_clock_data(mpsse_ctx
,
456 uint8_t last_bit
= 0;
457 if (field
->out_value
)
458 bit_copy(&last_bit
, 0, field
->out_value
, field
->num_bits
- 1, 1);
459 uint8_t tms_bits
= 0x01;
460 mpsse_clock_tms_cs(mpsse_ctx
,
468 tap_set_state(tap_state_transition(tap_get_state(), 1));
469 mpsse_clock_tms_cs_out(mpsse_ctx
,
475 tap_set_state(tap_state_transition(tap_get_state(), 0));
477 mpsse_clock_data(mpsse_ctx
,
486 if (tap_get_state() != tap_get_end_state())
487 move_to_state(tap_get_end_state());
489 DEBUG_JTAG_IO("%s scan, %i bits, end in %s",
490 (cmd
->cmd
.scan
->ir_scan
) ? "IR" : "DR", scan_size
,
491 tap_state_name(tap_get_end_state()));
494 static void ftdi_execute_reset(struct jtag_command
*cmd
)
496 DEBUG_JTAG_IO("reset trst: %i srst %i",
497 cmd
->cmd
.reset
->trst
, cmd
->cmd
.reset
->srst
);
499 if (cmd
->cmd
.reset
->trst
== 1
500 || (cmd
->cmd
.reset
->srst
501 && (jtag_get_reset_config() & RESET_SRST_PULLS_TRST
)))
502 tap_set_state(TAP_RESET
);
504 struct signal
*trst
= find_signal_by_name("nTRST");
505 if (cmd
->cmd
.reset
->trst
== 1) {
507 ftdi_set_signal(trst
, '0');
509 LOG_ERROR("Can't assert TRST: nTRST signal is not defined");
510 } else if (trst
&& jtag_get_reset_config() & RESET_HAS_TRST
&&
511 cmd
->cmd
.reset
->trst
== 0) {
512 if (jtag_get_reset_config() & RESET_TRST_OPEN_DRAIN
)
513 ftdi_set_signal(trst
, 'z');
515 ftdi_set_signal(trst
, '1');
518 struct signal
*srst
= find_signal_by_name("nSRST");
519 if (cmd
->cmd
.reset
->srst
== 1) {
521 ftdi_set_signal(srst
, '0');
523 LOG_ERROR("Can't assert SRST: nSRST signal is not defined");
524 } else if (srst
&& jtag_get_reset_config() & RESET_HAS_SRST
&&
525 cmd
->cmd
.reset
->srst
== 0) {
526 if (jtag_get_reset_config() & RESET_SRST_PUSH_PULL
)
527 ftdi_set_signal(srst
, '1');
529 ftdi_set_signal(srst
, 'z');
532 DEBUG_JTAG_IO("trst: %i, srst: %i",
533 cmd
->cmd
.reset
->trst
, cmd
->cmd
.reset
->srst
);
536 static void ftdi_execute_sleep(struct jtag_command
*cmd
)
538 DEBUG_JTAG_IO("sleep %" PRIi32
, cmd
->cmd
.sleep
->us
);
540 mpsse_flush(mpsse_ctx
);
541 jtag_sleep(cmd
->cmd
.sleep
->us
);
542 DEBUG_JTAG_IO("sleep %" PRIi32
" usec while in %s",
544 tap_state_name(tap_get_state()));
547 static void ftdi_execute_stableclocks(struct jtag_command
*cmd
)
549 /* this is only allowed while in a stable state. A check for a stable
550 * state was done in jtag_add_clocks()
552 int num_cycles
= cmd
->cmd
.stableclocks
->num_cycles
;
554 /* 7 bits of either ones or zeros. */
555 uint8_t tms
= tap_get_state() == TAP_RESET
? 0x7f : 0x00;
557 /* TODO: Use mpsse_clock_data with in=out=0 for this, if TMS can be set to
558 * the correct level and remain there during the scan */
559 while (num_cycles
> 0) {
560 /* there are no state transitions in this code, so omit state tracking */
561 unsigned this_len
= num_cycles
> 7 ? 7 : num_cycles
;
562 mpsse_clock_tms_cs_out(mpsse_ctx
, &tms
, 0, this_len
, false, ftdi_jtag_mode
);
563 num_cycles
-= this_len
;
566 DEBUG_JTAG_IO("clocks %i while in %s",
567 cmd
->cmd
.stableclocks
->num_cycles
,
568 tap_state_name(tap_get_state()));
571 static void ftdi_execute_command(struct jtag_command
*cmd
)
575 ftdi_execute_reset(cmd
);
578 ftdi_execute_runtest(cmd
);
581 ftdi_execute_statemove(cmd
);
584 ftdi_execute_pathmove(cmd
);
587 ftdi_execute_scan(cmd
);
590 ftdi_execute_sleep(cmd
);
592 case JTAG_STABLECLOCKS
:
593 ftdi_execute_stableclocks(cmd
);
596 ftdi_execute_tms(cmd
);
599 LOG_ERROR("BUG: unknown JTAG command type encountered: %d", cmd
->type
);
604 static int ftdi_execute_queue(void)
606 /* blink, if the current layout has that feature */
607 struct signal
*led
= find_signal_by_name("LED");
609 ftdi_set_signal(led
, '1');
611 for (struct jtag_command
*cmd
= jtag_command_queue
; cmd
; cmd
= cmd
->next
) {
612 /* fill the write buffer with the desired command */
613 ftdi_execute_command(cmd
);
617 ftdi_set_signal(led
, '0');
619 int retval
= mpsse_flush(mpsse_ctx
);
620 if (retval
!= ERROR_OK
)
621 LOG_ERROR("error while flushing MPSSE queue: %d", retval
);
626 static int ftdi_initialize(void)
628 if (tap_get_tms_path_len(TAP_IRPAUSE
, TAP_IRPAUSE
) == 7)
629 LOG_DEBUG("ftdi interface using 7 step jtag state transitions");
631 LOG_DEBUG("ftdi interface using shortest path jtag state transitions");
633 for (int i
= 0; ftdi_vid
[i
] || ftdi_pid
[i
]; i
++) {
634 mpsse_ctx
= mpsse_open(&ftdi_vid
[i
], &ftdi_pid
[i
], ftdi_device_desc
,
635 ftdi_serial
, ftdi_location
, ftdi_channel
);
641 return ERROR_JTAG_INIT_FAILED
;
643 output
= jtag_output_init
;
644 direction
= jtag_direction_init
;
647 struct signal
*sig
= find_signal_by_name("SWD_EN");
649 LOG_ERROR("SWD mode is active but SWD_EN signal is not defined");
650 return ERROR_JTAG_INIT_FAILED
;
652 /* A dummy SWD_EN would have zero mask */
654 ftdi_set_signal(sig
, '1');
657 mpsse_set_data_bits_low_byte(mpsse_ctx
, output
& 0xff, direction
& 0xff);
658 mpsse_set_data_bits_high_byte(mpsse_ctx
, output
>> 8, direction
>> 8);
660 mpsse_loopback_config(mpsse_ctx
, false);
662 freq
= mpsse_set_frequency(mpsse_ctx
, jtag_get_speed_khz() * 1000);
664 return mpsse_flush(mpsse_ctx
);
667 static int ftdi_quit(void)
669 mpsse_close(mpsse_ctx
);
676 COMMAND_HANDLER(ftdi_handle_device_desc_command
)
679 if (ftdi_device_desc
)
680 free(ftdi_device_desc
);
681 ftdi_device_desc
= strdup(CMD_ARGV
[0]);
683 LOG_ERROR("expected exactly one argument to ftdi_device_desc <description>");
689 COMMAND_HANDLER(ftdi_handle_serial_command
)
694 ftdi_serial
= strdup(CMD_ARGV
[0]);
696 return ERROR_COMMAND_SYNTAX_ERROR
;
702 COMMAND_HANDLER(ftdi_handle_location_command
)
707 ftdi_location
= strdup(CMD_ARGV
[0]);
709 return ERROR_COMMAND_SYNTAX_ERROR
;
715 COMMAND_HANDLER(ftdi_handle_channel_command
)
718 COMMAND_PARSE_NUMBER(u8
, CMD_ARGV
[0], ftdi_channel
);
720 return ERROR_COMMAND_SYNTAX_ERROR
;
725 COMMAND_HANDLER(ftdi_handle_layout_init_command
)
728 return ERROR_COMMAND_SYNTAX_ERROR
;
730 COMMAND_PARSE_NUMBER(u16
, CMD_ARGV
[0], jtag_output_init
);
731 COMMAND_PARSE_NUMBER(u16
, CMD_ARGV
[1], jtag_direction_init
);
736 COMMAND_HANDLER(ftdi_handle_layout_signal_command
)
739 return ERROR_COMMAND_SYNTAX_ERROR
;
741 bool invert_data
= false;
742 uint16_t data_mask
= 0;
743 bool invert_oe
= false;
744 uint16_t oe_mask
= 0;
745 for (unsigned i
= 1; i
< CMD_ARGC
; i
+= 2) {
746 if (strcmp("-data", CMD_ARGV
[i
]) == 0) {
748 COMMAND_PARSE_NUMBER(u16
, CMD_ARGV
[i
+ 1], data_mask
);
749 } else if (strcmp("-ndata", CMD_ARGV
[i
]) == 0) {
751 COMMAND_PARSE_NUMBER(u16
, CMD_ARGV
[i
+ 1], data_mask
);
752 } else if (strcmp("-oe", CMD_ARGV
[i
]) == 0) {
754 COMMAND_PARSE_NUMBER(u16
, CMD_ARGV
[i
+ 1], oe_mask
);
755 } else if (strcmp("-noe", CMD_ARGV
[i
]) == 0) {
757 COMMAND_PARSE_NUMBER(u16
, CMD_ARGV
[i
+ 1], oe_mask
);
758 } else if (!strcmp("-alias", CMD_ARGV
[i
]) ||
759 !strcmp("-nalias", CMD_ARGV
[i
])) {
760 if (!strcmp("-nalias", CMD_ARGV
[i
]))
762 struct signal
*sig
= find_signal_by_name(CMD_ARGV
[i
+ 1]);
764 LOG_ERROR("signal %s is not defined", CMD_ARGV
[i
+ 1]);
767 data_mask
= sig
->data_mask
;
768 oe_mask
= sig
->oe_mask
;
769 invert_oe
= sig
->invert_oe
;
770 invert_data
^= sig
->invert_data
;
772 LOG_ERROR("unknown option '%s'", CMD_ARGV
[i
]);
773 return ERROR_COMMAND_SYNTAX_ERROR
;
778 sig
= find_signal_by_name(CMD_ARGV
[0]);
780 sig
= create_signal(CMD_ARGV
[0]);
782 LOG_ERROR("failed to create signal %s", CMD_ARGV
[0]);
786 sig
->invert_data
= invert_data
;
787 sig
->data_mask
= data_mask
;
788 sig
->invert_oe
= invert_oe
;
789 sig
->oe_mask
= oe_mask
;
794 COMMAND_HANDLER(ftdi_handle_set_signal_command
)
797 return ERROR_COMMAND_SYNTAX_ERROR
;
800 sig
= find_signal_by_name(CMD_ARGV
[0]);
802 LOG_ERROR("interface configuration doesn't define signal '%s'", CMD_ARGV
[0]);
806 switch (*CMD_ARGV
[1]) {
811 /* single character level specifier only */
812 if (CMD_ARGV
[1][1] == '\0') {
813 ftdi_set_signal(sig
, *CMD_ARGV
[1]);
817 LOG_ERROR("unknown signal level '%s', use 0, 1 or z", CMD_ARGV
[1]);
818 return ERROR_COMMAND_SYNTAX_ERROR
;
821 return mpsse_flush(mpsse_ctx
);
824 COMMAND_HANDLER(ftdi_handle_vid_pid_command
)
826 if (CMD_ARGC
> MAX_USB_IDS
* 2) {
827 LOG_WARNING("ignoring extra IDs in ftdi_vid_pid "
828 "(maximum is %d pairs)", MAX_USB_IDS
);
829 CMD_ARGC
= MAX_USB_IDS
* 2;
831 if (CMD_ARGC
< 2 || (CMD_ARGC
& 1)) {
832 LOG_WARNING("incomplete ftdi_vid_pid configuration directive");
834 return ERROR_COMMAND_SYNTAX_ERROR
;
835 /* remove the incomplete trailing id */
840 for (i
= 0; i
< CMD_ARGC
; i
+= 2) {
841 COMMAND_PARSE_NUMBER(u16
, CMD_ARGV
[i
], ftdi_vid
[i
>> 1]);
842 COMMAND_PARSE_NUMBER(u16
, CMD_ARGV
[i
+ 1], ftdi_pid
[i
>> 1]);
846 * Explicitly terminate, in case there are multiples instances of
849 ftdi_vid
[i
>> 1] = ftdi_pid
[i
>> 1] = 0;
854 COMMAND_HANDLER(ftdi_handle_tdo_sample_edge_command
)
857 static const Jim_Nvp nvp_ftdi_jtag_modes
[] = {
858 { .name
= "rising", .value
= JTAG_MODE
},
859 { .name
= "falling", .value
= JTAG_MODE_ALT
},
860 { .name
= NULL
, .value
= -1 },
864 n
= Jim_Nvp_name2value_simple(nvp_ftdi_jtag_modes
, CMD_ARGV
[0]);
866 return ERROR_COMMAND_SYNTAX_ERROR
;
867 ftdi_jtag_mode
= n
->value
;
871 n
= Jim_Nvp_value2name_simple(nvp_ftdi_jtag_modes
, ftdi_jtag_mode
);
872 command_print(CMD_CTX
, "ftdi samples TDO on %s edge of TCK", n
->name
);
877 static const struct command_registration ftdi_command_handlers
[] = {
879 .name
= "ftdi_device_desc",
880 .handler
= &ftdi_handle_device_desc_command
,
881 .mode
= COMMAND_CONFIG
,
882 .help
= "set the USB device description of the FTDI device",
883 .usage
= "description_string",
886 .name
= "ftdi_serial",
887 .handler
= &ftdi_handle_serial_command
,
888 .mode
= COMMAND_CONFIG
,
889 .help
= "set the serial number of the FTDI device",
890 .usage
= "serial_string",
893 .name
= "ftdi_location",
894 .handler
= &ftdi_handle_location_command
,
895 .mode
= COMMAND_CONFIG
,
896 .help
= "set the USB bus location of the FTDI device",
897 .usage
= "<bus>:port[,port]...",
900 .name
= "ftdi_channel",
901 .handler
= &ftdi_handle_channel_command
,
902 .mode
= COMMAND_CONFIG
,
903 .help
= "set the channel of the FTDI device that is used as JTAG",
907 .name
= "ftdi_layout_init",
908 .handler
= &ftdi_handle_layout_init_command
,
909 .mode
= COMMAND_CONFIG
,
910 .help
= "initialize the FTDI GPIO signals used "
911 "to control output-enables and reset signals",
912 .usage
= "data direction",
915 .name
= "ftdi_layout_signal",
916 .handler
= &ftdi_handle_layout_signal_command
,
918 .help
= "define a signal controlled by one or more FTDI GPIO as data "
919 "and/or output enable",
920 .usage
= "name [-data mask|-ndata mask] [-oe mask|-noe mask] [-alias|-nalias name]",
923 .name
= "ftdi_set_signal",
924 .handler
= &ftdi_handle_set_signal_command
,
925 .mode
= COMMAND_EXEC
,
926 .help
= "control a layout-specific signal",
927 .usage
= "name (1|0|z)",
930 .name
= "ftdi_vid_pid",
931 .handler
= &ftdi_handle_vid_pid_command
,
932 .mode
= COMMAND_CONFIG
,
933 .help
= "the vendor ID and product ID of the FTDI device",
934 .usage
= "(vid pid)* ",
937 .name
= "ftdi_tdo_sample_edge",
938 .handler
= &ftdi_handle_tdo_sample_edge_command
,
940 .help
= "set which TCK clock edge is used for sampling TDO "
941 "- default is rising-edge (Setting to falling-edge may "
942 "allow signalling speed increase)",
943 .usage
= "(rising|falling)",
945 COMMAND_REGISTRATION_DONE
948 static int create_default_signal(const char *name
, uint16_t data_mask
)
950 struct signal
*sig
= create_signal(name
);
952 LOG_ERROR("failed to create signal %s", name
);
955 sig
->invert_data
= false;
956 sig
->data_mask
= data_mask
;
957 sig
->invert_oe
= false;
963 static int create_signals(void)
965 if (create_default_signal("TCK", 0x01) != ERROR_OK
)
967 if (create_default_signal("TDI", 0x02) != ERROR_OK
)
969 if (create_default_signal("TDO", 0x04) != ERROR_OK
)
971 if (create_default_signal("TMS", 0x08) != ERROR_OK
)
976 static int ftdi_swd_init(void)
978 LOG_INFO("FTDI SWD mode enabled");
981 if (create_signals() != ERROR_OK
)
984 swd_cmd_queue_alloced
= 10;
985 swd_cmd_queue
= malloc(swd_cmd_queue_alloced
* sizeof(*swd_cmd_queue
));
987 return swd_cmd_queue
!= NULL
? ERROR_OK
: ERROR_FAIL
;
990 static void ftdi_swd_swdio_en(bool enable
)
992 struct signal
*oe
= find_signal_by_name("SWDIO_OE");
994 ftdi_set_signal(oe
, enable
? '1' : '0');
998 * Flush the MPSSE queue and process the SWD transaction queue
1002 static int ftdi_swd_run_queue(void)
1004 LOG_DEBUG("Executing %zu queued transactions", swd_cmd_queue_length
);
1006 struct signal
*led
= find_signal_by_name("LED");
1008 if (queued_retval
!= ERROR_OK
) {
1009 LOG_DEBUG("Skipping due to previous errors: %d", queued_retval
);
1013 /* A transaction must be followed by another transaction or at least 8 idle cycles to
1014 * ensure that data is clocked through the AP. */
1015 mpsse_clock_data_out(mpsse_ctx
, NULL
, 0, 8, SWD_MODE
);
1017 /* Terminate the "blink", if the current layout has that feature */
1019 ftdi_set_signal(led
, '0');
1021 queued_retval
= mpsse_flush(mpsse_ctx
);
1022 if (queued_retval
!= ERROR_OK
) {
1023 LOG_ERROR("MPSSE failed");
1027 for (size_t i
= 0; i
< swd_cmd_queue_length
; i
++) {
1028 int ack
= buf_get_u32(swd_cmd_queue
[i
].trn_ack_data_parity_trn
, 1, 3);
1030 LOG_DEBUG("%s %s %s reg %X = %08"PRIx32
,
1031 ack
== SWD_ACK_OK
? "OK" : ack
== SWD_ACK_WAIT
? "WAIT" : ack
== SWD_ACK_FAULT
? "FAULT" : "JUNK",
1032 swd_cmd_queue
[i
].cmd
& SWD_CMD_APnDP
? "AP" : "DP",
1033 swd_cmd_queue
[i
].cmd
& SWD_CMD_RnW
? "read" : "write",
1034 (swd_cmd_queue
[i
].cmd
& SWD_CMD_A32
) >> 1,
1035 buf_get_u32(swd_cmd_queue
[i
].trn_ack_data_parity_trn
,
1036 1 + 3 + (swd_cmd_queue
[i
].cmd
& SWD_CMD_RnW
? 0 : 1), 32));
1038 if (ack
!= SWD_ACK_OK
) {
1039 queued_retval
= ack
== SWD_ACK_WAIT
? ERROR_WAIT
: ERROR_FAIL
;
1042 } else if (swd_cmd_queue
[i
].cmd
& SWD_CMD_RnW
) {
1043 uint32_t data
= buf_get_u32(swd_cmd_queue
[i
].trn_ack_data_parity_trn
, 1 + 3, 32);
1044 int parity
= buf_get_u32(swd_cmd_queue
[i
].trn_ack_data_parity_trn
, 1 + 3 + 32, 1);
1046 if (parity
!= parity_u32(data
)) {
1047 LOG_ERROR("SWD Read data parity mismatch");
1048 queued_retval
= ERROR_FAIL
;
1052 if (swd_cmd_queue
[i
].dst
!= NULL
)
1053 *swd_cmd_queue
[i
].dst
= data
;
1058 swd_cmd_queue_length
= 0;
1059 retval
= queued_retval
;
1060 queued_retval
= ERROR_OK
;
1062 /* Queue a new "blink" */
1063 if (led
&& retval
== ERROR_OK
)
1064 ftdi_set_signal(led
, '1');
1069 static void ftdi_swd_queue_cmd(uint8_t cmd
, uint32_t *dst
, uint32_t data
, uint32_t ap_delay_clk
)
1071 if (swd_cmd_queue_length
>= swd_cmd_queue_alloced
) {
1072 /* Not enough room in the queue. Run the queue and increase its size for next time.
1073 * Note that it's not possible to avoid running the queue here, because mpsse contains
1074 * pointers into the queue which may be invalid after the realloc. */
1075 queued_retval
= ftdi_swd_run_queue();
1076 struct swd_cmd_queue_entry
*q
= realloc(swd_cmd_queue
, swd_cmd_queue_alloced
* 2 * sizeof(*swd_cmd_queue
));
1079 swd_cmd_queue_alloced
*= 2;
1080 LOG_DEBUG("Increased SWD command queue to %zu elements", swd_cmd_queue_alloced
);
1084 if (queued_retval
!= ERROR_OK
)
1087 size_t i
= swd_cmd_queue_length
++;
1088 swd_cmd_queue
[i
].cmd
= cmd
| SWD_CMD_START
| SWD_CMD_PARK
;
1090 mpsse_clock_data_out(mpsse_ctx
, &swd_cmd_queue
[i
].cmd
, 0, 8, SWD_MODE
);
1092 if (swd_cmd_queue
[i
].cmd
& SWD_CMD_RnW
) {
1093 /* Queue a read transaction */
1094 swd_cmd_queue
[i
].dst
= dst
;
1096 ftdi_swd_swdio_en(false);
1097 mpsse_clock_data_in(mpsse_ctx
, swd_cmd_queue
[i
].trn_ack_data_parity_trn
,
1098 0, 1 + 3 + 32 + 1 + 1, SWD_MODE
);
1099 ftdi_swd_swdio_en(true);
1101 /* Queue a write transaction */
1102 ftdi_swd_swdio_en(false);
1104 mpsse_clock_data_in(mpsse_ctx
, swd_cmd_queue
[i
].trn_ack_data_parity_trn
,
1105 0, 1 + 3 + 1, SWD_MODE
);
1107 ftdi_swd_swdio_en(true);
1109 buf_set_u32(swd_cmd_queue
[i
].trn_ack_data_parity_trn
, 1 + 3 + 1, 32, data
);
1110 buf_set_u32(swd_cmd_queue
[i
].trn_ack_data_parity_trn
, 1 + 3 + 1 + 32, 1, parity_u32(data
));
1112 mpsse_clock_data_out(mpsse_ctx
, swd_cmd_queue
[i
].trn_ack_data_parity_trn
,
1113 1 + 3 + 1, 32 + 1, SWD_MODE
);
1116 /* Insert idle cycles after AP accesses to avoid WAIT */
1117 if (cmd
& SWD_CMD_APnDP
)
1118 mpsse_clock_data_out(mpsse_ctx
, NULL
, 0, ap_delay_clk
, SWD_MODE
);
1122 static void ftdi_swd_read_reg(uint8_t cmd
, uint32_t *value
, uint32_t ap_delay_clk
)
1124 assert(cmd
& SWD_CMD_RnW
);
1125 ftdi_swd_queue_cmd(cmd
, value
, 0, ap_delay_clk
);
1128 static void ftdi_swd_write_reg(uint8_t cmd
, uint32_t value
, uint32_t ap_delay_clk
)
1130 assert(!(cmd
& SWD_CMD_RnW
));
1131 ftdi_swd_queue_cmd(cmd
, NULL
, value
, ap_delay_clk
);
1134 static int_least32_t ftdi_swd_frequency(int_least32_t hz
)
1137 freq
= mpsse_set_frequency(mpsse_ctx
, hz
);
1142 static int ftdi_swd_switch_seq(enum swd_special_seq seq
)
1146 LOG_DEBUG("SWD line reset");
1147 mpsse_clock_data_out(mpsse_ctx
, swd_seq_line_reset
, 0, swd_seq_line_reset_len
, SWD_MODE
);
1150 LOG_DEBUG("JTAG-to-SWD");
1151 mpsse_clock_data_out(mpsse_ctx
, swd_seq_jtag_to_swd
, 0, swd_seq_jtag_to_swd_len
, SWD_MODE
);
1154 LOG_DEBUG("SWD-to-JTAG");
1155 mpsse_clock_data_out(mpsse_ctx
, swd_seq_swd_to_jtag
, 0, swd_seq_swd_to_jtag_len
, SWD_MODE
);
1158 LOG_ERROR("Sequence %d not supported", seq
);
1165 static const struct swd_driver ftdi_swd
= {
1166 .init
= ftdi_swd_init
,
1167 .frequency
= ftdi_swd_frequency
,
1168 .switch_seq
= ftdi_swd_switch_seq
,
1169 .read_reg
= ftdi_swd_read_reg
,
1170 .write_reg
= ftdi_swd_write_reg
,
1171 .run
= ftdi_swd_run_queue
,
1174 static const char * const ftdi_transports
[] = { "jtag", "swd", NULL
};
1176 struct jtag_interface ftdi_interface
= {
1178 .supported
= DEBUG_CAP_TMS_SEQ
,
1179 .commands
= ftdi_command_handlers
,
1180 .transports
= ftdi_transports
,
1183 .init
= ftdi_initialize
,
1185 .speed
= ftdi_speed
,
1186 .speed_div
= ftdi_speed_div
,
1188 .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)