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
;
131 static int ftdi_swd_switch_seq(struct adiv5_dap
*dap
, enum swd_special_seq seq
);
133 static struct signal
*find_signal_by_name(const char *name
)
135 for (struct signal
*sig
= signals
; sig
; sig
= sig
->next
) {
136 if (strcmp(name
, sig
->name
) == 0)
142 static struct signal
*create_signal(const char *name
)
144 struct signal
**psig
= &signals
;
146 psig
= &(*psig
)->next
;
148 *psig
= calloc(1, sizeof(**psig
));
152 (*psig
)->name
= strdup(name
);
153 if ((*psig
)->name
== NULL
) {
160 static int ftdi_set_signal(const struct signal
*s
, char value
)
165 if (s
->data_mask
== 0 && s
->oe_mask
== 0) {
166 LOG_ERROR("interface doesn't provide signal '%s'", s
->name
);
171 data
= s
->invert_data
;
175 if (s
->data_mask
== 0) {
176 LOG_ERROR("interface can't drive '%s' high", s
->name
);
179 data
= !s
->invert_data
;
184 if (s
->oe_mask
== 0) {
185 LOG_ERROR("interface can't tri-state '%s'", s
->name
);
188 data
= s
->invert_data
;
192 assert(0 && "invalid signal level specifier");
196 uint16_t old_output
= output
;
197 uint16_t old_direction
= direction
;
199 output
= data
? output
| s
->data_mask
: output
& ~s
->data_mask
;
200 if (s
->oe_mask
== s
->data_mask
)
201 direction
= oe
? direction
| s
->oe_mask
: direction
& ~s
->oe_mask
;
203 output
= oe
? output
| s
->oe_mask
: output
& ~s
->oe_mask
;
205 if ((output
& 0xff) != (old_output
& 0xff) || (direction
& 0xff) != (old_direction
& 0xff))
206 mpsse_set_data_bits_low_byte(mpsse_ctx
, output
& 0xff, direction
& 0xff);
207 if ((output
>> 8 != old_output
>> 8) || (direction
>> 8 != old_direction
>> 8))
208 mpsse_set_data_bits_high_byte(mpsse_ctx
, output
>> 8, direction
>> 8);
215 * Function move_to_state
216 * moves the TAP controller from the current state to a
217 * \a goal_state through a path given by tap_get_tms_path(). State transition
218 * logging is performed by delegation to clock_tms().
220 * @param goal_state is the destination state for the move.
222 static void move_to_state(tap_state_t goal_state
)
224 tap_state_t start_state
= tap_get_state();
226 /* goal_state is 1/2 of a tuple/pair of states which allow convenient
227 lookup of the required TMS pattern to move to this state from the
231 /* do the 2 lookups */
232 uint8_t tms_bits
= tap_get_tms_path(start_state
, goal_state
);
233 int tms_count
= tap_get_tms_path_len(start_state
, goal_state
);
234 assert(tms_count
<= 8);
236 DEBUG_JTAG_IO("start=%s goal=%s", tap_state_name(start_state
), tap_state_name(goal_state
));
238 /* Track state transitions step by step */
239 for (int i
= 0; i
< tms_count
; i
++)
240 tap_set_state(tap_state_transition(tap_get_state(), (tms_bits
>> i
) & 1));
242 mpsse_clock_tms_cs_out(mpsse_ctx
,
250 static int ftdi_speed(int speed
)
253 retval
= mpsse_set_frequency(mpsse_ctx
, speed
);
256 LOG_ERROR("couldn't set FTDI TCK speed");
263 static int ftdi_speed_div(int speed
, int *khz
)
269 static int ftdi_khz(int khz
, int *jtag_speed
)
271 if (khz
== 0 && !mpsse_is_high_speed(mpsse_ctx
)) {
272 LOG_DEBUG("RCLK not supported");
276 *jtag_speed
= khz
* 1000;
280 static void ftdi_end_state(tap_state_t state
)
282 if (tap_is_state_stable(state
))
283 tap_set_end_state(state
);
285 LOG_ERROR("BUG: %s is not a stable end state", tap_state_name(state
));
290 static void ftdi_execute_runtest(struct jtag_command
*cmd
)
295 DEBUG_JTAG_IO("runtest %i cycles, end in %s",
296 cmd
->cmd
.runtest
->num_cycles
,
297 tap_state_name(cmd
->cmd
.runtest
->end_state
));
299 if (tap_get_state() != TAP_IDLE
)
300 move_to_state(TAP_IDLE
);
302 /* TODO: Reuse ftdi_execute_stableclocks */
303 i
= cmd
->cmd
.runtest
->num_cycles
;
305 /* there are no state transitions in this code, so omit state tracking */
306 unsigned this_len
= i
> 7 ? 7 : i
;
307 mpsse_clock_tms_cs_out(mpsse_ctx
, &zero
, 0, this_len
, false, JTAG_MODE
);
311 ftdi_end_state(cmd
->cmd
.runtest
->end_state
);
313 if (tap_get_state() != tap_get_end_state())
314 move_to_state(tap_get_end_state());
316 DEBUG_JTAG_IO("runtest: %i, end in %s",
317 cmd
->cmd
.runtest
->num_cycles
,
318 tap_state_name(tap_get_end_state()));
321 static void ftdi_execute_statemove(struct jtag_command
*cmd
)
323 DEBUG_JTAG_IO("statemove end in %s",
324 tap_state_name(cmd
->cmd
.statemove
->end_state
));
326 ftdi_end_state(cmd
->cmd
.statemove
->end_state
);
328 /* shortest-path move to desired end state */
329 if (tap_get_state() != tap_get_end_state() || tap_get_end_state() == TAP_RESET
)
330 move_to_state(tap_get_end_state());
334 * Clock a bunch of TMS (or SWDIO) transitions, to change the JTAG
335 * (or SWD) state machine. REVISIT: Not the best method, perhaps.
337 static void ftdi_execute_tms(struct jtag_command
*cmd
)
339 DEBUG_JTAG_IO("TMS: %d bits", cmd
->cmd
.tms
->num_bits
);
341 /* TODO: Missing tap state tracking, also missing from ft2232.c! */
342 mpsse_clock_tms_cs_out(mpsse_ctx
,
345 cmd
->cmd
.tms
->num_bits
,
350 static void ftdi_execute_pathmove(struct jtag_command
*cmd
)
352 tap_state_t
*path
= cmd
->cmd
.pathmove
->path
;
353 int num_states
= cmd
->cmd
.pathmove
->num_states
;
355 DEBUG_JTAG_IO("pathmove: %i states, current: %s end: %s", num_states
,
356 tap_state_name(tap_get_state()),
357 tap_state_name(path
[num_states
-1]));
360 unsigned bit_count
= 0;
361 uint8_t tms_byte
= 0;
365 /* this loop verifies that the path is legal and logs each state in the path */
366 while (num_states
--) {
368 /* either TMS=0 or TMS=1 must work ... */
369 if (tap_state_transition(tap_get_state(), false)
370 == path
[state_count
])
371 buf_set_u32(&tms_byte
, bit_count
++, 1, 0x0);
372 else if (tap_state_transition(tap_get_state(), true)
373 == path
[state_count
]) {
374 buf_set_u32(&tms_byte
, bit_count
++, 1, 0x1);
376 /* ... or else the caller goofed BADLY */
378 LOG_ERROR("BUG: %s -> %s isn't a valid "
379 "TAP state transition",
380 tap_state_name(tap_get_state()),
381 tap_state_name(path
[state_count
]));
385 tap_set_state(path
[state_count
]);
388 if (bit_count
== 7 || num_states
== 0) {
389 mpsse_clock_tms_cs_out(mpsse_ctx
,
398 tap_set_end_state(tap_get_state());
401 static void ftdi_execute_scan(struct jtag_command
*cmd
)
403 DEBUG_JTAG_IO("%s type:%d", cmd
->cmd
.scan
->ir_scan
? "IRSCAN" : "DRSCAN",
404 jtag_scan_type(cmd
->cmd
.scan
));
406 /* Make sure there are no trailing fields with num_bits == 0, or the logic below will fail. */
407 while (cmd
->cmd
.scan
->num_fields
> 0
408 && cmd
->cmd
.scan
->fields
[cmd
->cmd
.scan
->num_fields
- 1].num_bits
== 0) {
409 cmd
->cmd
.scan
->num_fields
--;
410 LOG_DEBUG("discarding trailing empty field");
413 if (cmd
->cmd
.scan
->num_fields
== 0) {
414 LOG_DEBUG("empty scan, doing nothing");
418 if (cmd
->cmd
.scan
->ir_scan
) {
419 if (tap_get_state() != TAP_IRSHIFT
)
420 move_to_state(TAP_IRSHIFT
);
422 if (tap_get_state() != TAP_DRSHIFT
)
423 move_to_state(TAP_DRSHIFT
);
426 ftdi_end_state(cmd
->cmd
.scan
->end_state
);
428 struct scan_field
*field
= cmd
->cmd
.scan
->fields
;
429 unsigned scan_size
= 0;
431 for (int i
= 0; i
< cmd
->cmd
.scan
->num_fields
; i
++, field
++) {
432 scan_size
+= field
->num_bits
;
433 DEBUG_JTAG_IO("%s%s field %d/%d %d bits",
434 field
->in_value
? "in" : "",
435 field
->out_value
? "out" : "",
437 cmd
->cmd
.scan
->num_fields
,
440 if (i
== cmd
->cmd
.scan
->num_fields
- 1 && tap_get_state() != tap_get_end_state()) {
441 /* Last field, and we're leaving IRSHIFT/DRSHIFT. Clock last bit during tap
442 * movement. This last field can't have length zero, it was checked above. */
443 mpsse_clock_data(mpsse_ctx
,
450 uint8_t last_bit
= 0;
451 if (field
->out_value
)
452 bit_copy(&last_bit
, 0, field
->out_value
, field
->num_bits
- 1, 1);
453 uint8_t tms_bits
= 0x01;
454 mpsse_clock_tms_cs(mpsse_ctx
,
462 tap_set_state(tap_state_transition(tap_get_state(), 1));
463 mpsse_clock_tms_cs_out(mpsse_ctx
,
469 tap_set_state(tap_state_transition(tap_get_state(), 0));
471 mpsse_clock_data(mpsse_ctx
,
480 if (tap_get_state() != tap_get_end_state())
481 move_to_state(tap_get_end_state());
483 DEBUG_JTAG_IO("%s scan, %i bits, end in %s",
484 (cmd
->cmd
.scan
->ir_scan
) ? "IR" : "DR", scan_size
,
485 tap_state_name(tap_get_end_state()));
488 static void ftdi_execute_reset(struct jtag_command
*cmd
)
490 DEBUG_JTAG_IO("reset trst: %i srst %i",
491 cmd
->cmd
.reset
->trst
, cmd
->cmd
.reset
->srst
);
493 if (cmd
->cmd
.reset
->trst
== 1
494 || (cmd
->cmd
.reset
->srst
495 && (jtag_get_reset_config() & RESET_SRST_PULLS_TRST
)))
496 tap_set_state(TAP_RESET
);
498 struct signal
*trst
= find_signal_by_name("nTRST");
499 if (cmd
->cmd
.reset
->trst
== 1) {
501 ftdi_set_signal(trst
, '0');
503 LOG_ERROR("Can't assert TRST: nTRST signal is not defined");
504 } else if (trst
&& jtag_get_reset_config() & RESET_HAS_TRST
&&
505 cmd
->cmd
.reset
->trst
== 0) {
506 if (jtag_get_reset_config() & RESET_TRST_OPEN_DRAIN
)
507 ftdi_set_signal(trst
, 'z');
509 ftdi_set_signal(trst
, '1');
512 struct signal
*srst
= find_signal_by_name("nSRST");
513 if (cmd
->cmd
.reset
->srst
== 1) {
515 ftdi_set_signal(srst
, '0');
517 LOG_ERROR("Can't assert SRST: nSRST signal is not defined");
518 } else if (srst
&& jtag_get_reset_config() & RESET_HAS_SRST
&&
519 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
= jtag_output_init
;
638 direction
= jtag_direction_init
;
641 struct signal
*sig
= find_signal_by_name("SWD_EN");
643 LOG_ERROR("SWD mode is active but SWD_EN signal is not defined");
644 return ERROR_JTAG_INIT_FAILED
;
646 /* A dummy SWD_EN would have zero mask */
648 ftdi_set_signal(sig
, '1');
651 mpsse_set_data_bits_low_byte(mpsse_ctx
, output
& 0xff, direction
& 0xff);
652 mpsse_set_data_bits_high_byte(mpsse_ctx
, output
>> 8, direction
>> 8);
654 mpsse_loopback_config(mpsse_ctx
, false);
656 /* Set a low default */
657 freq
= mpsse_set_frequency(mpsse_ctx
, 1000);
660 ftdi_swd_switch_seq(NULL
, JTAG_TO_SWD
);
662 ftdi_swd_switch_seq(NULL
, SWD_TO_JTAG
);
664 return mpsse_flush(mpsse_ctx
);
667 static int ftdi_quit(void)
669 mpsse_close(mpsse_ctx
);
674 COMMAND_HANDLER(ftdi_handle_device_desc_command
)
677 if (ftdi_device_desc
)
678 free(ftdi_device_desc
);
679 ftdi_device_desc
= strdup(CMD_ARGV
[0]);
681 LOG_ERROR("expected exactly one argument to ftdi_device_desc <description>");
687 COMMAND_HANDLER(ftdi_handle_serial_command
)
692 ftdi_serial
= strdup(CMD_ARGV
[0]);
694 return ERROR_COMMAND_SYNTAX_ERROR
;
700 COMMAND_HANDLER(ftdi_handle_channel_command
)
703 COMMAND_PARSE_NUMBER(u8
, CMD_ARGV
[0], ftdi_channel
);
705 return ERROR_COMMAND_SYNTAX_ERROR
;
710 COMMAND_HANDLER(ftdi_handle_layout_init_command
)
713 return ERROR_COMMAND_SYNTAX_ERROR
;
715 COMMAND_PARSE_NUMBER(u16
, CMD_ARGV
[0], jtag_output_init
);
716 COMMAND_PARSE_NUMBER(u16
, CMD_ARGV
[1], jtag_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 .usage
= "data direction",
870 .name
= "ftdi_layout_signal",
871 .handler
= &ftdi_handle_layout_signal_command
,
873 .help
= "define a signal controlled by one or more FTDI GPIO as data "
874 "and/or output enable",
875 .usage
= "name [-data mask|-ndata mask] [-oe mask|-noe mask] [-alias|-nalias name]",
878 .name
= "ftdi_set_signal",
879 .handler
= &ftdi_handle_set_signal_command
,
880 .mode
= COMMAND_EXEC
,
881 .help
= "control a layout-specific signal",
882 .usage
= "name (1|0|z)",
885 .name
= "ftdi_vid_pid",
886 .handler
= &ftdi_handle_vid_pid_command
,
887 .mode
= COMMAND_CONFIG
,
888 .help
= "the vendor ID and product ID of the FTDI device",
889 .usage
= "(vid pid)* ",
891 COMMAND_REGISTRATION_DONE
894 static int create_default_signal(const char *name
, uint16_t data_mask
)
896 struct signal
*sig
= create_signal(name
);
898 LOG_ERROR("failed to create signal %s", name
);
901 sig
->invert_data
= false;
902 sig
->data_mask
= data_mask
;
903 sig
->invert_oe
= false;
909 static int create_signals(void)
911 if (create_default_signal("TCK", 0x01) != ERROR_OK
)
913 if (create_default_signal("TDI", 0x02) != ERROR_OK
)
915 if (create_default_signal("TDO", 0x04) != ERROR_OK
)
917 if (create_default_signal("TMS", 0x08) != ERROR_OK
)
922 static int ftdi_swd_init(void)
924 LOG_INFO("FTDI SWD mode enabled");
927 if (create_signals() != ERROR_OK
)
930 swd_cmd_queue_alloced
= 10;
931 swd_cmd_queue
= malloc(swd_cmd_queue_alloced
* sizeof(*swd_cmd_queue
));
933 return swd_cmd_queue
!= NULL
? ERROR_OK
: ERROR_FAIL
;
936 static void ftdi_swd_swdio_en(bool enable
)
938 struct signal
*oe
= find_signal_by_name("SWDIO_OE");
940 ftdi_set_signal(oe
, enable
? '1' : '0');
944 * Flush the MPSSE queue and process the SWD transaction queue
948 static int ftdi_swd_run_queue(struct adiv5_dap
*dap
)
950 LOG_DEBUG("Executing %zu queued transactions", swd_cmd_queue_length
);
952 struct signal
*led
= find_signal_by_name("LED");
954 if (queued_retval
!= ERROR_OK
) {
955 LOG_DEBUG("Skipping due to previous errors: %d", queued_retval
);
959 /* A transaction must be followed by another transaction or at least 8 idle cycles to
960 * ensure that data is clocked through the AP. */
961 mpsse_clock_data_out(mpsse_ctx
, NULL
, 0, 8, SWD_MODE
);
963 /* Terminate the "blink", if the current layout has that feature */
965 ftdi_set_signal(led
, '0');
967 queued_retval
= mpsse_flush(mpsse_ctx
);
968 if (queued_retval
!= ERROR_OK
) {
969 LOG_ERROR("MPSSE failed");
973 for (size_t i
= 0; i
< swd_cmd_queue_length
; i
++) {
974 int ack
= buf_get_u32(&swd_cmd_queue
[i
].trn_ack_data_parity_trn
, 1, 3);
976 LOG_DEBUG("%s %s %s reg %X = %08"PRIx32
,
977 ack
== SWD_ACK_OK
? "OK" : ack
== SWD_ACK_WAIT
? "WAIT" : ack
== SWD_ACK_FAULT
? "FAULT" : "JUNK",
978 swd_cmd_queue
[i
].cmd
& SWD_CMD_APnDP
? "AP" : "DP",
979 swd_cmd_queue
[i
].cmd
& SWD_CMD_RnW
? "read" : "write",
980 (swd_cmd_queue
[i
].cmd
& SWD_CMD_A32
) >> 1,
981 buf_get_u32(swd_cmd_queue
[i
].trn_ack_data_parity_trn
,
982 1 + 3 + (swd_cmd_queue
[i
].cmd
& SWD_CMD_RnW
? 0 : 1), 32));
984 if (ack
!= SWD_ACK_OK
) {
988 } else if (swd_cmd_queue
[i
].cmd
& SWD_CMD_RnW
) {
989 uint32_t data
= buf_get_u32(swd_cmd_queue
[i
].trn_ack_data_parity_trn
, 1 + 3, 32);
990 int parity
= buf_get_u32(swd_cmd_queue
[i
].trn_ack_data_parity_trn
, 1 + 3 + 32, 1);
992 if (parity
!= parity_u32(data
)) {
993 LOG_ERROR("SWD Read data parity mismatch");
994 queued_retval
= ERROR_FAIL
;
998 if (swd_cmd_queue
[i
].dst
!= NULL
)
999 *swd_cmd_queue
[i
].dst
= data
;
1004 swd_cmd_queue_length
= 0;
1005 retval
= queued_retval
;
1006 queued_retval
= ERROR_OK
;
1008 /* Queue a new "blink" */
1009 if (led
&& retval
== ERROR_OK
)
1010 ftdi_set_signal(led
, '1');
1015 static void ftdi_swd_queue_cmd(struct adiv5_dap
*dap
, uint8_t cmd
, uint32_t *dst
, uint32_t data
)
1017 if (swd_cmd_queue_length
>= swd_cmd_queue_alloced
) {
1018 /* Not enough room in the queue. Run the queue and increase its size for next time.
1019 * Note that it's not possible to avoid running the queue here, because mpsse contains
1020 * pointers into the queue which may be invalid after the realloc. */
1021 queued_retval
= ftdi_swd_run_queue(dap
);
1022 struct swd_cmd_queue_entry
*q
= realloc(swd_cmd_queue
, swd_cmd_queue_alloced
* 2 * sizeof(*swd_cmd_queue
));
1025 swd_cmd_queue_alloced
*= 2;
1026 LOG_DEBUG("Increased SWD command queue to %zu elements", swd_cmd_queue_alloced
);
1030 if (queued_retval
!= ERROR_OK
)
1033 size_t i
= swd_cmd_queue_length
++;
1034 swd_cmd_queue
[i
].cmd
= cmd
| SWD_CMD_START
| SWD_CMD_PARK
;
1036 mpsse_clock_data_out(mpsse_ctx
, &swd_cmd_queue
[i
].cmd
, 0, 8, SWD_MODE
);
1038 if (swd_cmd_queue
[i
].cmd
& SWD_CMD_RnW
) {
1039 /* Queue a read transaction */
1040 swd_cmd_queue
[i
].dst
= dst
;
1042 ftdi_swd_swdio_en(false);
1043 mpsse_clock_data_in(mpsse_ctx
, swd_cmd_queue
[i
].trn_ack_data_parity_trn
,
1044 0, 1 + 3 + 32 + 1 + 1, SWD_MODE
);
1045 ftdi_swd_swdio_en(true);
1047 /* Queue a write transaction */
1048 ftdi_swd_swdio_en(false);
1050 mpsse_clock_data_in(mpsse_ctx
, swd_cmd_queue
[i
].trn_ack_data_parity_trn
,
1051 0, 1 + 3 + 1, SWD_MODE
);
1053 ftdi_swd_swdio_en(true);
1055 buf_set_u32(swd_cmd_queue
[i
].trn_ack_data_parity_trn
, 1 + 3 + 1, 32, data
);
1056 buf_set_u32(swd_cmd_queue
[i
].trn_ack_data_parity_trn
, 1 + 3 + 1 + 32, 1, parity_u32(data
));
1058 mpsse_clock_data_out(mpsse_ctx
, swd_cmd_queue
[i
].trn_ack_data_parity_trn
,
1059 1 + 3 + 1, 32 + 1, SWD_MODE
);
1062 /* Insert idle cycles after AP accesses to avoid WAIT */
1063 if (cmd
& SWD_CMD_APnDP
)
1064 mpsse_clock_data_out(mpsse_ctx
, NULL
, 0, dap
->memaccess_tck
, SWD_MODE
);
1068 static void ftdi_swd_read_reg(struct adiv5_dap
*dap
, uint8_t cmd
, uint32_t *value
)
1070 assert(cmd
& SWD_CMD_RnW
);
1071 ftdi_swd_queue_cmd(dap
, cmd
, value
, 0);
1074 static void ftdi_swd_write_reg(struct adiv5_dap
*dap
, uint8_t cmd
, uint32_t value
)
1076 assert(!(cmd
& SWD_CMD_RnW
));
1077 ftdi_swd_queue_cmd(dap
, cmd
, NULL
, value
);
1080 static int_least32_t ftdi_swd_frequency(struct adiv5_dap
*dap
, int_least32_t hz
)
1083 freq
= mpsse_set_frequency(mpsse_ctx
, hz
);
1088 static int ftdi_swd_switch_seq(struct adiv5_dap
*dap
, enum swd_special_seq seq
)
1092 LOG_DEBUG("SWD line reset");
1093 mpsse_clock_data_out(mpsse_ctx
, swd_seq_line_reset
, 0, swd_seq_line_reset_len
, SWD_MODE
);
1096 LOG_DEBUG("JTAG-to-SWD");
1097 mpsse_clock_data_out(mpsse_ctx
, swd_seq_jtag_to_swd
, 0, swd_seq_jtag_to_swd_len
, SWD_MODE
);
1100 LOG_DEBUG("SWD-to-JTAG");
1101 mpsse_clock_data_out(mpsse_ctx
, swd_seq_swd_to_jtag
, 0, swd_seq_swd_to_jtag_len
, SWD_MODE
);
1104 LOG_ERROR("Sequence %d not supported", seq
);
1111 static const struct swd_driver ftdi_swd
= {
1112 .init
= ftdi_swd_init
,
1113 .frequency
= ftdi_swd_frequency
,
1114 .switch_seq
= ftdi_swd_switch_seq
,
1115 .read_reg
= ftdi_swd_read_reg
,
1116 .write_reg
= ftdi_swd_write_reg
,
1117 .run
= ftdi_swd_run_queue
,
1120 static const char * const ftdi_transports
[] = { "jtag", "swd", NULL
};
1122 struct jtag_interface ftdi_interface
= {
1124 .supported
= DEBUG_CAP_TMS_SEQ
,
1125 .commands
= ftdi_command_handlers
,
1126 .transports
= ftdi_transports
,
1129 .init
= ftdi_initialize
,
1131 .speed
= ftdi_speed
,
1132 .speed_div
= ftdi_speed_div
,
1134 .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)