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 uint8_t ftdi_channel
;
95 static uint8_t ftdi_jtag_mode
= JTAG_MODE
;
100 /* vid = pid = 0 marks the end of the list */
101 static uint16_t ftdi_vid
[MAX_USB_IDS
+ 1] = { 0 };
102 static uint16_t ftdi_pid
[MAX_USB_IDS
+ 1] = { 0 };
104 static struct mpsse_ctx
*mpsse_ctx
;
115 static struct signal
*signals
;
117 /* FIXME: Where to store per-instance data? We need an SWD context. */
118 static struct swd_cmd_queue_entry
{
121 uint8_t trn_ack_data_parity_trn
[DIV_ROUND_UP(4 + 3 + 32 + 1 + 4, 8)];
123 static size_t swd_cmd_queue_length
;
124 static size_t swd_cmd_queue_alloced
;
125 static int queued_retval
;
128 static uint16_t output
;
129 static uint16_t direction
;
130 static uint16_t jtag_output_init
;
131 static uint16_t jtag_direction_init
;
133 static int ftdi_swd_switch_seq(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");
262 if (!swd_mode
&& speed
>= 10000000 && ftdi_jtag_mode
!= JTAG_MODE_ALT
)
263 LOG_INFO("ftdi: if you experience problems at higher adapter clocks, try "
264 "the command \"ftdi_tdo_sample_edge falling\"");
268 static int ftdi_speed_div(int speed
, int *khz
)
274 static int ftdi_khz(int khz
, int *jtag_speed
)
276 if (khz
== 0 && !mpsse_is_high_speed(mpsse_ctx
)) {
277 LOG_DEBUG("RCLK not supported");
281 *jtag_speed
= khz
* 1000;
285 static void ftdi_end_state(tap_state_t state
)
287 if (tap_is_state_stable(state
))
288 tap_set_end_state(state
);
290 LOG_ERROR("BUG: %s is not a stable end state", tap_state_name(state
));
295 static void ftdi_execute_runtest(struct jtag_command
*cmd
)
300 DEBUG_JTAG_IO("runtest %i cycles, end in %s",
301 cmd
->cmd
.runtest
->num_cycles
,
302 tap_state_name(cmd
->cmd
.runtest
->end_state
));
304 if (tap_get_state() != TAP_IDLE
)
305 move_to_state(TAP_IDLE
);
307 /* TODO: Reuse ftdi_execute_stableclocks */
308 i
= cmd
->cmd
.runtest
->num_cycles
;
310 /* there are no state transitions in this code, so omit state tracking */
311 unsigned this_len
= i
> 7 ? 7 : i
;
312 mpsse_clock_tms_cs_out(mpsse_ctx
, &zero
, 0, this_len
, false, ftdi_jtag_mode
);
316 ftdi_end_state(cmd
->cmd
.runtest
->end_state
);
318 if (tap_get_state() != tap_get_end_state())
319 move_to_state(tap_get_end_state());
321 DEBUG_JTAG_IO("runtest: %i, end in %s",
322 cmd
->cmd
.runtest
->num_cycles
,
323 tap_state_name(tap_get_end_state()));
326 static void ftdi_execute_statemove(struct jtag_command
*cmd
)
328 DEBUG_JTAG_IO("statemove end in %s",
329 tap_state_name(cmd
->cmd
.statemove
->end_state
));
331 ftdi_end_state(cmd
->cmd
.statemove
->end_state
);
333 /* shortest-path move to desired end state */
334 if (tap_get_state() != tap_get_end_state() || tap_get_end_state() == TAP_RESET
)
335 move_to_state(tap_get_end_state());
339 * Clock a bunch of TMS (or SWDIO) transitions, to change the JTAG
340 * (or SWD) state machine. REVISIT: Not the best method, perhaps.
342 static void ftdi_execute_tms(struct jtag_command
*cmd
)
344 DEBUG_JTAG_IO("TMS: %d bits", cmd
->cmd
.tms
->num_bits
);
346 /* TODO: Missing tap state tracking, also missing from ft2232.c! */
347 mpsse_clock_tms_cs_out(mpsse_ctx
,
350 cmd
->cmd
.tms
->num_bits
,
355 static void ftdi_execute_pathmove(struct jtag_command
*cmd
)
357 tap_state_t
*path
= cmd
->cmd
.pathmove
->path
;
358 int num_states
= cmd
->cmd
.pathmove
->num_states
;
360 DEBUG_JTAG_IO("pathmove: %i states, current: %s end: %s", num_states
,
361 tap_state_name(tap_get_state()),
362 tap_state_name(path
[num_states
-1]));
365 unsigned bit_count
= 0;
366 uint8_t tms_byte
= 0;
370 /* this loop verifies that the path is legal and logs each state in the path */
371 while (num_states
--) {
373 /* either TMS=0 or TMS=1 must work ... */
374 if (tap_state_transition(tap_get_state(), false)
375 == path
[state_count
])
376 buf_set_u32(&tms_byte
, bit_count
++, 1, 0x0);
377 else if (tap_state_transition(tap_get_state(), true)
378 == path
[state_count
]) {
379 buf_set_u32(&tms_byte
, bit_count
++, 1, 0x1);
381 /* ... or else the caller goofed BADLY */
383 LOG_ERROR("BUG: %s -> %s isn't a valid "
384 "TAP state transition",
385 tap_state_name(tap_get_state()),
386 tap_state_name(path
[state_count
]));
390 tap_set_state(path
[state_count
]);
393 if (bit_count
== 7 || num_states
== 0) {
394 mpsse_clock_tms_cs_out(mpsse_ctx
,
403 tap_set_end_state(tap_get_state());
406 static void ftdi_execute_scan(struct jtag_command
*cmd
)
408 DEBUG_JTAG_IO("%s type:%d", cmd
->cmd
.scan
->ir_scan
? "IRSCAN" : "DRSCAN",
409 jtag_scan_type(cmd
->cmd
.scan
));
411 /* Make sure there are no trailing fields with num_bits == 0, or the logic below will fail. */
412 while (cmd
->cmd
.scan
->num_fields
> 0
413 && cmd
->cmd
.scan
->fields
[cmd
->cmd
.scan
->num_fields
- 1].num_bits
== 0) {
414 cmd
->cmd
.scan
->num_fields
--;
415 LOG_DEBUG("discarding trailing empty field");
418 if (cmd
->cmd
.scan
->num_fields
== 0) {
419 LOG_DEBUG("empty scan, doing nothing");
423 if (cmd
->cmd
.scan
->ir_scan
) {
424 if (tap_get_state() != TAP_IRSHIFT
)
425 move_to_state(TAP_IRSHIFT
);
427 if (tap_get_state() != TAP_DRSHIFT
)
428 move_to_state(TAP_DRSHIFT
);
431 ftdi_end_state(cmd
->cmd
.scan
->end_state
);
433 struct scan_field
*field
= cmd
->cmd
.scan
->fields
;
434 unsigned scan_size
= 0;
436 for (int i
= 0; i
< cmd
->cmd
.scan
->num_fields
; i
++, field
++) {
437 scan_size
+= field
->num_bits
;
438 DEBUG_JTAG_IO("%s%s field %d/%d %d bits",
439 field
->in_value
? "in" : "",
440 field
->out_value
? "out" : "",
442 cmd
->cmd
.scan
->num_fields
,
445 if (i
== cmd
->cmd
.scan
->num_fields
- 1 && tap_get_state() != tap_get_end_state()) {
446 /* Last field, and we're leaving IRSHIFT/DRSHIFT. Clock last bit during tap
447 * movement. This last field can't have length zero, it was checked above. */
448 mpsse_clock_data(mpsse_ctx
,
455 uint8_t last_bit
= 0;
456 if (field
->out_value
)
457 bit_copy(&last_bit
, 0, field
->out_value
, field
->num_bits
- 1, 1);
458 uint8_t tms_bits
= 0x01;
459 mpsse_clock_tms_cs(mpsse_ctx
,
467 tap_set_state(tap_state_transition(tap_get_state(), 1));
468 mpsse_clock_tms_cs_out(mpsse_ctx
,
474 tap_set_state(tap_state_transition(tap_get_state(), 0));
476 mpsse_clock_data(mpsse_ctx
,
485 if (tap_get_state() != tap_get_end_state())
486 move_to_state(tap_get_end_state());
488 DEBUG_JTAG_IO("%s scan, %i bits, end in %s",
489 (cmd
->cmd
.scan
->ir_scan
) ? "IR" : "DR", scan_size
,
490 tap_state_name(tap_get_end_state()));
493 static void ftdi_execute_reset(struct jtag_command
*cmd
)
495 DEBUG_JTAG_IO("reset trst: %i srst %i",
496 cmd
->cmd
.reset
->trst
, cmd
->cmd
.reset
->srst
);
498 if (cmd
->cmd
.reset
->trst
== 1
499 || (cmd
->cmd
.reset
->srst
500 && (jtag_get_reset_config() & RESET_SRST_PULLS_TRST
)))
501 tap_set_state(TAP_RESET
);
503 struct signal
*trst
= find_signal_by_name("nTRST");
504 if (cmd
->cmd
.reset
->trst
== 1) {
506 ftdi_set_signal(trst
, '0');
508 LOG_ERROR("Can't assert TRST: nTRST signal is not defined");
509 } else if (trst
&& jtag_get_reset_config() & RESET_HAS_TRST
&&
510 cmd
->cmd
.reset
->trst
== 0) {
511 if (jtag_get_reset_config() & RESET_TRST_OPEN_DRAIN
)
512 ftdi_set_signal(trst
, 'z');
514 ftdi_set_signal(trst
, '1');
517 struct signal
*srst
= find_signal_by_name("nSRST");
518 if (cmd
->cmd
.reset
->srst
== 1) {
520 ftdi_set_signal(srst
, '0');
522 LOG_ERROR("Can't assert SRST: nSRST signal is not defined");
523 } else if (srst
&& jtag_get_reset_config() & RESET_HAS_SRST
&&
524 cmd
->cmd
.reset
->srst
== 0) {
525 if (jtag_get_reset_config() & RESET_SRST_PUSH_PULL
)
526 ftdi_set_signal(srst
, '1');
528 ftdi_set_signal(srst
, 'z');
531 DEBUG_JTAG_IO("trst: %i, srst: %i",
532 cmd
->cmd
.reset
->trst
, cmd
->cmd
.reset
->srst
);
535 static void ftdi_execute_sleep(struct jtag_command
*cmd
)
537 DEBUG_JTAG_IO("sleep %" PRIi32
, cmd
->cmd
.sleep
->us
);
539 mpsse_flush(mpsse_ctx
);
540 jtag_sleep(cmd
->cmd
.sleep
->us
);
541 DEBUG_JTAG_IO("sleep %" PRIi32
" usec while in %s",
543 tap_state_name(tap_get_state()));
546 static void ftdi_execute_stableclocks(struct jtag_command
*cmd
)
548 /* this is only allowed while in a stable state. A check for a stable
549 * state was done in jtag_add_clocks()
551 int num_cycles
= cmd
->cmd
.stableclocks
->num_cycles
;
553 /* 7 bits of either ones or zeros. */
554 uint8_t tms
= tap_get_state() == TAP_RESET
? 0x7f : 0x00;
556 /* TODO: Use mpsse_clock_data with in=out=0 for this, if TMS can be set to
557 * the correct level and remain there during the scan */
558 while (num_cycles
> 0) {
559 /* there are no state transitions in this code, so omit state tracking */
560 unsigned this_len
= num_cycles
> 7 ? 7 : num_cycles
;
561 mpsse_clock_tms_cs_out(mpsse_ctx
, &tms
, 0, this_len
, false, ftdi_jtag_mode
);
562 num_cycles
-= this_len
;
565 DEBUG_JTAG_IO("clocks %i while in %s",
566 cmd
->cmd
.stableclocks
->num_cycles
,
567 tap_state_name(tap_get_state()));
570 static void ftdi_execute_command(struct jtag_command
*cmd
)
574 ftdi_execute_reset(cmd
);
577 ftdi_execute_runtest(cmd
);
580 ftdi_execute_statemove(cmd
);
583 ftdi_execute_pathmove(cmd
);
586 ftdi_execute_scan(cmd
);
589 ftdi_execute_sleep(cmd
);
591 case JTAG_STABLECLOCKS
:
592 ftdi_execute_stableclocks(cmd
);
595 ftdi_execute_tms(cmd
);
598 LOG_ERROR("BUG: unknown JTAG command type encountered: %d", cmd
->type
);
603 static int ftdi_execute_queue(void)
605 /* blink, if the current layout has that feature */
606 struct signal
*led
= find_signal_by_name("LED");
608 ftdi_set_signal(led
, '1');
610 for (struct jtag_command
*cmd
= jtag_command_queue
; cmd
; cmd
= cmd
->next
) {
611 /* fill the write buffer with the desired command */
612 ftdi_execute_command(cmd
);
616 ftdi_set_signal(led
, '0');
618 int retval
= mpsse_flush(mpsse_ctx
);
619 if (retval
!= ERROR_OK
)
620 LOG_ERROR("error while flushing MPSSE queue: %d", retval
);
625 static int ftdi_initialize(void)
627 if (tap_get_tms_path_len(TAP_IRPAUSE
, TAP_IRPAUSE
) == 7)
628 LOG_DEBUG("ftdi interface using 7 step jtag state transitions");
630 LOG_DEBUG("ftdi interface using shortest path jtag state transitions");
632 for (int i
= 0; ftdi_vid
[i
] || ftdi_pid
[i
]; i
++) {
633 mpsse_ctx
= mpsse_open(&ftdi_vid
[i
], &ftdi_pid
[i
], ftdi_device_desc
,
634 ftdi_serial
, ftdi_channel
);
640 return ERROR_JTAG_INIT_FAILED
;
642 output
= jtag_output_init
;
643 direction
= jtag_direction_init
;
646 struct signal
*sig
= find_signal_by_name("SWD_EN");
648 LOG_ERROR("SWD mode is active but SWD_EN signal is not defined");
649 return ERROR_JTAG_INIT_FAILED
;
651 /* A dummy SWD_EN would have zero mask */
653 ftdi_set_signal(sig
, '1');
656 mpsse_set_data_bits_low_byte(mpsse_ctx
, output
& 0xff, direction
& 0xff);
657 mpsse_set_data_bits_high_byte(mpsse_ctx
, output
>> 8, direction
>> 8);
659 mpsse_loopback_config(mpsse_ctx
, false);
661 freq
= mpsse_set_frequency(mpsse_ctx
, jtag_get_speed_khz() * 1000);
663 return mpsse_flush(mpsse_ctx
);
666 static int ftdi_quit(void)
668 mpsse_close(mpsse_ctx
);
675 COMMAND_HANDLER(ftdi_handle_device_desc_command
)
678 if (ftdi_device_desc
)
679 free(ftdi_device_desc
);
680 ftdi_device_desc
= strdup(CMD_ARGV
[0]);
682 LOG_ERROR("expected exactly one argument to ftdi_device_desc <description>");
688 COMMAND_HANDLER(ftdi_handle_serial_command
)
693 ftdi_serial
= strdup(CMD_ARGV
[0]);
695 return ERROR_COMMAND_SYNTAX_ERROR
;
701 COMMAND_HANDLER(ftdi_handle_channel_command
)
704 COMMAND_PARSE_NUMBER(u8
, CMD_ARGV
[0], ftdi_channel
);
706 return ERROR_COMMAND_SYNTAX_ERROR
;
711 COMMAND_HANDLER(ftdi_handle_layout_init_command
)
714 return ERROR_COMMAND_SYNTAX_ERROR
;
716 COMMAND_PARSE_NUMBER(u16
, CMD_ARGV
[0], jtag_output_init
);
717 COMMAND_PARSE_NUMBER(u16
, CMD_ARGV
[1], jtag_direction_init
);
722 COMMAND_HANDLER(ftdi_handle_layout_signal_command
)
725 return ERROR_COMMAND_SYNTAX_ERROR
;
727 bool invert_data
= false;
728 uint16_t data_mask
= 0;
729 bool invert_oe
= false;
730 uint16_t oe_mask
= 0;
731 for (unsigned i
= 1; i
< CMD_ARGC
; i
+= 2) {
732 if (strcmp("-data", CMD_ARGV
[i
]) == 0) {
734 COMMAND_PARSE_NUMBER(u16
, CMD_ARGV
[i
+ 1], data_mask
);
735 } else if (strcmp("-ndata", CMD_ARGV
[i
]) == 0) {
737 COMMAND_PARSE_NUMBER(u16
, CMD_ARGV
[i
+ 1], data_mask
);
738 } else if (strcmp("-oe", CMD_ARGV
[i
]) == 0) {
740 COMMAND_PARSE_NUMBER(u16
, CMD_ARGV
[i
+ 1], oe_mask
);
741 } else if (strcmp("-noe", CMD_ARGV
[i
]) == 0) {
743 COMMAND_PARSE_NUMBER(u16
, CMD_ARGV
[i
+ 1], oe_mask
);
744 } else if (!strcmp("-alias", CMD_ARGV
[i
]) ||
745 !strcmp("-nalias", CMD_ARGV
[i
])) {
746 if (!strcmp("-nalias", CMD_ARGV
[i
]))
748 struct signal
*sig
= find_signal_by_name(CMD_ARGV
[i
+ 1]);
750 LOG_ERROR("signal %s is not defined", CMD_ARGV
[i
+ 1]);
753 data_mask
= sig
->data_mask
;
754 oe_mask
= sig
->oe_mask
;
755 invert_oe
= sig
->invert_oe
;
756 invert_data
^= sig
->invert_data
;
758 LOG_ERROR("unknown option '%s'", CMD_ARGV
[i
]);
759 return ERROR_COMMAND_SYNTAX_ERROR
;
764 sig
= find_signal_by_name(CMD_ARGV
[0]);
766 sig
= create_signal(CMD_ARGV
[0]);
768 LOG_ERROR("failed to create signal %s", CMD_ARGV
[0]);
772 sig
->invert_data
= invert_data
;
773 sig
->data_mask
= data_mask
;
774 sig
->invert_oe
= invert_oe
;
775 sig
->oe_mask
= oe_mask
;
780 COMMAND_HANDLER(ftdi_handle_set_signal_command
)
783 return ERROR_COMMAND_SYNTAX_ERROR
;
786 sig
= find_signal_by_name(CMD_ARGV
[0]);
788 LOG_ERROR("interface configuration doesn't define signal '%s'", CMD_ARGV
[0]);
792 switch (*CMD_ARGV
[1]) {
797 /* single character level specifier only */
798 if (CMD_ARGV
[1][1] == '\0') {
799 ftdi_set_signal(sig
, *CMD_ARGV
[1]);
803 LOG_ERROR("unknown signal level '%s', use 0, 1 or z", CMD_ARGV
[1]);
804 return ERROR_COMMAND_SYNTAX_ERROR
;
807 return mpsse_flush(mpsse_ctx
);
810 COMMAND_HANDLER(ftdi_handle_vid_pid_command
)
812 if (CMD_ARGC
> MAX_USB_IDS
* 2) {
813 LOG_WARNING("ignoring extra IDs in ftdi_vid_pid "
814 "(maximum is %d pairs)", MAX_USB_IDS
);
815 CMD_ARGC
= MAX_USB_IDS
* 2;
817 if (CMD_ARGC
< 2 || (CMD_ARGC
& 1)) {
818 LOG_WARNING("incomplete ftdi_vid_pid configuration directive");
820 return ERROR_COMMAND_SYNTAX_ERROR
;
821 /* remove the incomplete trailing id */
826 for (i
= 0; i
< CMD_ARGC
; i
+= 2) {
827 COMMAND_PARSE_NUMBER(u16
, CMD_ARGV
[i
], ftdi_vid
[i
>> 1]);
828 COMMAND_PARSE_NUMBER(u16
, CMD_ARGV
[i
+ 1], ftdi_pid
[i
>> 1]);
832 * Explicitly terminate, in case there are multiples instances of
835 ftdi_vid
[i
>> 1] = ftdi_pid
[i
>> 1] = 0;
840 COMMAND_HANDLER(ftdi_handle_tdo_sample_edge_command
)
843 static const Jim_Nvp nvp_ftdi_jtag_modes
[] = {
844 { .name
= "rising", .value
= JTAG_MODE
},
845 { .name
= "falling", .value
= JTAG_MODE_ALT
},
846 { .name
= NULL
, .value
= -1 },
850 n
= Jim_Nvp_name2value_simple(nvp_ftdi_jtag_modes
, CMD_ARGV
[0]);
852 return ERROR_COMMAND_SYNTAX_ERROR
;
853 ftdi_jtag_mode
= n
->value
;
857 n
= Jim_Nvp_value2name_simple(nvp_ftdi_jtag_modes
, ftdi_jtag_mode
);
858 command_print(CMD_CTX
, "ftdi samples TDO on %s edge of TCK", n
->name
);
863 static const struct command_registration ftdi_command_handlers
[] = {
865 .name
= "ftdi_device_desc",
866 .handler
= &ftdi_handle_device_desc_command
,
867 .mode
= COMMAND_CONFIG
,
868 .help
= "set the USB device description of the FTDI device",
869 .usage
= "description_string",
872 .name
= "ftdi_serial",
873 .handler
= &ftdi_handle_serial_command
,
874 .mode
= COMMAND_CONFIG
,
875 .help
= "set the serial number of the FTDI device",
876 .usage
= "serial_string",
879 .name
= "ftdi_channel",
880 .handler
= &ftdi_handle_channel_command
,
881 .mode
= COMMAND_CONFIG
,
882 .help
= "set the channel of the FTDI device that is used as JTAG",
886 .name
= "ftdi_layout_init",
887 .handler
= &ftdi_handle_layout_init_command
,
888 .mode
= COMMAND_CONFIG
,
889 .help
= "initialize the FTDI GPIO signals used "
890 "to control output-enables and reset signals",
891 .usage
= "data direction",
894 .name
= "ftdi_layout_signal",
895 .handler
= &ftdi_handle_layout_signal_command
,
897 .help
= "define a signal controlled by one or more FTDI GPIO as data "
898 "and/or output enable",
899 .usage
= "name [-data mask|-ndata mask] [-oe mask|-noe mask] [-alias|-nalias name]",
902 .name
= "ftdi_set_signal",
903 .handler
= &ftdi_handle_set_signal_command
,
904 .mode
= COMMAND_EXEC
,
905 .help
= "control a layout-specific signal",
906 .usage
= "name (1|0|z)",
909 .name
= "ftdi_vid_pid",
910 .handler
= &ftdi_handle_vid_pid_command
,
911 .mode
= COMMAND_CONFIG
,
912 .help
= "the vendor ID and product ID of the FTDI device",
913 .usage
= "(vid pid)* ",
916 .name
= "ftdi_tdo_sample_edge",
917 .handler
= &ftdi_handle_tdo_sample_edge_command
,
919 .help
= "set which TCK clock edge is used for sampling TDO "
920 "- default is rising-edge (Setting to falling-edge may "
921 "allow signalling speed increase)",
922 .usage
= "(rising|falling)",
924 COMMAND_REGISTRATION_DONE
927 static int create_default_signal(const char *name
, uint16_t data_mask
)
929 struct signal
*sig
= create_signal(name
);
931 LOG_ERROR("failed to create signal %s", name
);
934 sig
->invert_data
= false;
935 sig
->data_mask
= data_mask
;
936 sig
->invert_oe
= false;
942 static int create_signals(void)
944 if (create_default_signal("TCK", 0x01) != ERROR_OK
)
946 if (create_default_signal("TDI", 0x02) != ERROR_OK
)
948 if (create_default_signal("TDO", 0x04) != ERROR_OK
)
950 if (create_default_signal("TMS", 0x08) != ERROR_OK
)
955 static int ftdi_swd_init(void)
957 LOG_INFO("FTDI SWD mode enabled");
960 if (create_signals() != ERROR_OK
)
963 swd_cmd_queue_alloced
= 10;
964 swd_cmd_queue
= malloc(swd_cmd_queue_alloced
* sizeof(*swd_cmd_queue
));
966 return swd_cmd_queue
!= NULL
? ERROR_OK
: ERROR_FAIL
;
969 static void ftdi_swd_swdio_en(bool enable
)
971 struct signal
*oe
= find_signal_by_name("SWDIO_OE");
973 ftdi_set_signal(oe
, enable
? '1' : '0');
977 * Flush the MPSSE queue and process the SWD transaction queue
981 static int ftdi_swd_run_queue(void)
983 LOG_DEBUG("Executing %zu queued transactions", swd_cmd_queue_length
);
985 struct signal
*led
= find_signal_by_name("LED");
987 if (queued_retval
!= ERROR_OK
) {
988 LOG_DEBUG("Skipping due to previous errors: %d", queued_retval
);
992 /* A transaction must be followed by another transaction or at least 8 idle cycles to
993 * ensure that data is clocked through the AP. */
994 mpsse_clock_data_out(mpsse_ctx
, NULL
, 0, 8, SWD_MODE
);
996 /* Terminate the "blink", if the current layout has that feature */
998 ftdi_set_signal(led
, '0');
1000 queued_retval
= mpsse_flush(mpsse_ctx
);
1001 if (queued_retval
!= ERROR_OK
) {
1002 LOG_ERROR("MPSSE failed");
1006 for (size_t i
= 0; i
< swd_cmd_queue_length
; i
++) {
1007 int ack
= buf_get_u32(swd_cmd_queue
[i
].trn_ack_data_parity_trn
, 1, 3);
1009 LOG_DEBUG("%s %s %s reg %X = %08"PRIx32
,
1010 ack
== SWD_ACK_OK
? "OK" : ack
== SWD_ACK_WAIT
? "WAIT" : ack
== SWD_ACK_FAULT
? "FAULT" : "JUNK",
1011 swd_cmd_queue
[i
].cmd
& SWD_CMD_APnDP
? "AP" : "DP",
1012 swd_cmd_queue
[i
].cmd
& SWD_CMD_RnW
? "read" : "write",
1013 (swd_cmd_queue
[i
].cmd
& SWD_CMD_A32
) >> 1,
1014 buf_get_u32(swd_cmd_queue
[i
].trn_ack_data_parity_trn
,
1015 1 + 3 + (swd_cmd_queue
[i
].cmd
& SWD_CMD_RnW
? 0 : 1), 32));
1017 if (ack
!= SWD_ACK_OK
) {
1018 queued_retval
= ack
== SWD_ACK_WAIT
? ERROR_WAIT
: ERROR_FAIL
;
1021 } else if (swd_cmd_queue
[i
].cmd
& SWD_CMD_RnW
) {
1022 uint32_t data
= buf_get_u32(swd_cmd_queue
[i
].trn_ack_data_parity_trn
, 1 + 3, 32);
1023 int parity
= buf_get_u32(swd_cmd_queue
[i
].trn_ack_data_parity_trn
, 1 + 3 + 32, 1);
1025 if (parity
!= parity_u32(data
)) {
1026 LOG_ERROR("SWD Read data parity mismatch");
1027 queued_retval
= ERROR_FAIL
;
1031 if (swd_cmd_queue
[i
].dst
!= NULL
)
1032 *swd_cmd_queue
[i
].dst
= data
;
1037 swd_cmd_queue_length
= 0;
1038 retval
= queued_retval
;
1039 queued_retval
= ERROR_OK
;
1041 /* Queue a new "blink" */
1042 if (led
&& retval
== ERROR_OK
)
1043 ftdi_set_signal(led
, '1');
1048 static void ftdi_swd_queue_cmd(uint8_t cmd
, uint32_t *dst
, uint32_t data
, uint32_t ap_delay_clk
)
1050 if (swd_cmd_queue_length
>= swd_cmd_queue_alloced
) {
1051 /* Not enough room in the queue. Run the queue and increase its size for next time.
1052 * Note that it's not possible to avoid running the queue here, because mpsse contains
1053 * pointers into the queue which may be invalid after the realloc. */
1054 queued_retval
= ftdi_swd_run_queue();
1055 struct swd_cmd_queue_entry
*q
= realloc(swd_cmd_queue
, swd_cmd_queue_alloced
* 2 * sizeof(*swd_cmd_queue
));
1058 swd_cmd_queue_alloced
*= 2;
1059 LOG_DEBUG("Increased SWD command queue to %zu elements", swd_cmd_queue_alloced
);
1063 if (queued_retval
!= ERROR_OK
)
1066 size_t i
= swd_cmd_queue_length
++;
1067 swd_cmd_queue
[i
].cmd
= cmd
| SWD_CMD_START
| SWD_CMD_PARK
;
1069 mpsse_clock_data_out(mpsse_ctx
, &swd_cmd_queue
[i
].cmd
, 0, 8, SWD_MODE
);
1071 if (swd_cmd_queue
[i
].cmd
& SWD_CMD_RnW
) {
1072 /* Queue a read transaction */
1073 swd_cmd_queue
[i
].dst
= dst
;
1075 ftdi_swd_swdio_en(false);
1076 mpsse_clock_data_in(mpsse_ctx
, swd_cmd_queue
[i
].trn_ack_data_parity_trn
,
1077 0, 1 + 3 + 32 + 1 + 1, SWD_MODE
);
1078 ftdi_swd_swdio_en(true);
1080 /* Queue a write transaction */
1081 ftdi_swd_swdio_en(false);
1083 mpsse_clock_data_in(mpsse_ctx
, swd_cmd_queue
[i
].trn_ack_data_parity_trn
,
1084 0, 1 + 3 + 1, SWD_MODE
);
1086 ftdi_swd_swdio_en(true);
1088 buf_set_u32(swd_cmd_queue
[i
].trn_ack_data_parity_trn
, 1 + 3 + 1, 32, data
);
1089 buf_set_u32(swd_cmd_queue
[i
].trn_ack_data_parity_trn
, 1 + 3 + 1 + 32, 1, parity_u32(data
));
1091 mpsse_clock_data_out(mpsse_ctx
, swd_cmd_queue
[i
].trn_ack_data_parity_trn
,
1092 1 + 3 + 1, 32 + 1, SWD_MODE
);
1095 /* Insert idle cycles after AP accesses to avoid WAIT */
1096 if (cmd
& SWD_CMD_APnDP
)
1097 mpsse_clock_data_out(mpsse_ctx
, NULL
, 0, ap_delay_clk
, SWD_MODE
);
1101 static void ftdi_swd_read_reg(uint8_t cmd
, uint32_t *value
, uint32_t ap_delay_clk
)
1103 assert(cmd
& SWD_CMD_RnW
);
1104 ftdi_swd_queue_cmd(cmd
, value
, 0, ap_delay_clk
);
1107 static void ftdi_swd_write_reg(uint8_t cmd
, uint32_t value
, uint32_t ap_delay_clk
)
1109 assert(!(cmd
& SWD_CMD_RnW
));
1110 ftdi_swd_queue_cmd(cmd
, NULL
, value
, ap_delay_clk
);
1113 static int_least32_t ftdi_swd_frequency(int_least32_t hz
)
1116 freq
= mpsse_set_frequency(mpsse_ctx
, hz
);
1121 static int ftdi_swd_switch_seq(enum swd_special_seq seq
)
1125 LOG_DEBUG("SWD line reset");
1126 mpsse_clock_data_out(mpsse_ctx
, swd_seq_line_reset
, 0, swd_seq_line_reset_len
, SWD_MODE
);
1129 LOG_DEBUG("JTAG-to-SWD");
1130 mpsse_clock_data_out(mpsse_ctx
, swd_seq_jtag_to_swd
, 0, swd_seq_jtag_to_swd_len
, SWD_MODE
);
1133 LOG_DEBUG("SWD-to-JTAG");
1134 mpsse_clock_data_out(mpsse_ctx
, swd_seq_swd_to_jtag
, 0, swd_seq_swd_to_jtag_len
, SWD_MODE
);
1137 LOG_ERROR("Sequence %d not supported", seq
);
1144 static const struct swd_driver ftdi_swd
= {
1145 .init
= ftdi_swd_init
,
1146 .frequency
= ftdi_swd_frequency
,
1147 .switch_seq
= ftdi_swd_switch_seq
,
1148 .read_reg
= ftdi_swd_read_reg
,
1149 .write_reg
= ftdi_swd_write_reg
,
1150 .run
= ftdi_swd_run_queue
,
1153 static const char * const ftdi_transports
[] = { "jtag", "swd", NULL
};
1155 struct jtag_interface ftdi_interface
= {
1157 .supported
= DEBUG_CAP_TMS_SEQ
,
1158 .commands
= ftdi_command_handlers
,
1159 .transports
= ftdi_transports
,
1162 .init
= ftdi_initialize
,
1164 .speed
= ftdi_speed
,
1165 .speed_div
= ftdi_speed_div
,
1167 .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)