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 freq
= mpsse_set_frequency(mpsse_ctx
, jtag_get_speed_khz() * 1000);
658 return mpsse_flush(mpsse_ctx
);
661 static int ftdi_quit(void)
663 mpsse_close(mpsse_ctx
);
668 COMMAND_HANDLER(ftdi_handle_device_desc_command
)
671 if (ftdi_device_desc
)
672 free(ftdi_device_desc
);
673 ftdi_device_desc
= strdup(CMD_ARGV
[0]);
675 LOG_ERROR("expected exactly one argument to ftdi_device_desc <description>");
681 COMMAND_HANDLER(ftdi_handle_serial_command
)
686 ftdi_serial
= strdup(CMD_ARGV
[0]);
688 return ERROR_COMMAND_SYNTAX_ERROR
;
694 COMMAND_HANDLER(ftdi_handle_channel_command
)
697 COMMAND_PARSE_NUMBER(u8
, CMD_ARGV
[0], ftdi_channel
);
699 return ERROR_COMMAND_SYNTAX_ERROR
;
704 COMMAND_HANDLER(ftdi_handle_layout_init_command
)
707 return ERROR_COMMAND_SYNTAX_ERROR
;
709 COMMAND_PARSE_NUMBER(u16
, CMD_ARGV
[0], jtag_output_init
);
710 COMMAND_PARSE_NUMBER(u16
, CMD_ARGV
[1], jtag_direction_init
);
715 COMMAND_HANDLER(ftdi_handle_layout_signal_command
)
718 return ERROR_COMMAND_SYNTAX_ERROR
;
720 bool invert_data
= false;
721 uint16_t data_mask
= 0;
722 bool invert_oe
= false;
723 uint16_t oe_mask
= 0;
724 for (unsigned i
= 1; i
< CMD_ARGC
; i
+= 2) {
725 if (strcmp("-data", CMD_ARGV
[i
]) == 0) {
727 COMMAND_PARSE_NUMBER(u16
, CMD_ARGV
[i
+ 1], data_mask
);
728 } else if (strcmp("-ndata", CMD_ARGV
[i
]) == 0) {
730 COMMAND_PARSE_NUMBER(u16
, CMD_ARGV
[i
+ 1], data_mask
);
731 } else if (strcmp("-oe", CMD_ARGV
[i
]) == 0) {
733 COMMAND_PARSE_NUMBER(u16
, CMD_ARGV
[i
+ 1], oe_mask
);
734 } else if (strcmp("-noe", CMD_ARGV
[i
]) == 0) {
736 COMMAND_PARSE_NUMBER(u16
, CMD_ARGV
[i
+ 1], oe_mask
);
737 } else if (!strcmp("-alias", CMD_ARGV
[i
]) ||
738 !strcmp("-nalias", CMD_ARGV
[i
])) {
739 if (!strcmp("-nalias", CMD_ARGV
[i
]))
741 struct signal
*sig
= find_signal_by_name(CMD_ARGV
[i
+ 1]);
743 LOG_ERROR("signal %s is not defined", CMD_ARGV
[i
+ 1]);
746 data_mask
= sig
->data_mask
;
747 oe_mask
= sig
->oe_mask
;
748 invert_oe
= sig
->invert_oe
;
749 invert_data
^= sig
->invert_data
;
751 LOG_ERROR("unknown option '%s'", CMD_ARGV
[i
]);
752 return ERROR_COMMAND_SYNTAX_ERROR
;
757 sig
= find_signal_by_name(CMD_ARGV
[0]);
759 sig
= create_signal(CMD_ARGV
[0]);
761 LOG_ERROR("failed to create signal %s", CMD_ARGV
[0]);
765 sig
->invert_data
= invert_data
;
766 sig
->data_mask
= data_mask
;
767 sig
->invert_oe
= invert_oe
;
768 sig
->oe_mask
= oe_mask
;
773 COMMAND_HANDLER(ftdi_handle_set_signal_command
)
776 return ERROR_COMMAND_SYNTAX_ERROR
;
779 sig
= find_signal_by_name(CMD_ARGV
[0]);
781 LOG_ERROR("interface configuration doesn't define signal '%s'", CMD_ARGV
[0]);
785 switch (*CMD_ARGV
[1]) {
790 /* single character level specifier only */
791 if (CMD_ARGV
[1][1] == '\0') {
792 ftdi_set_signal(sig
, *CMD_ARGV
[1]);
796 LOG_ERROR("unknown signal level '%s', use 0, 1 or z", CMD_ARGV
[1]);
797 return ERROR_COMMAND_SYNTAX_ERROR
;
800 return mpsse_flush(mpsse_ctx
);
803 COMMAND_HANDLER(ftdi_handle_vid_pid_command
)
805 if (CMD_ARGC
> MAX_USB_IDS
* 2) {
806 LOG_WARNING("ignoring extra IDs in ftdi_vid_pid "
807 "(maximum is %d pairs)", MAX_USB_IDS
);
808 CMD_ARGC
= MAX_USB_IDS
* 2;
810 if (CMD_ARGC
< 2 || (CMD_ARGC
& 1)) {
811 LOG_WARNING("incomplete ftdi_vid_pid configuration directive");
813 return ERROR_COMMAND_SYNTAX_ERROR
;
814 /* remove the incomplete trailing id */
819 for (i
= 0; i
< CMD_ARGC
; i
+= 2) {
820 COMMAND_PARSE_NUMBER(u16
, CMD_ARGV
[i
], ftdi_vid
[i
>> 1]);
821 COMMAND_PARSE_NUMBER(u16
, CMD_ARGV
[i
+ 1], ftdi_pid
[i
>> 1]);
825 * Explicitly terminate, in case there are multiples instances of
828 ftdi_vid
[i
>> 1] = ftdi_pid
[i
>> 1] = 0;
833 static const struct command_registration ftdi_command_handlers
[] = {
835 .name
= "ftdi_device_desc",
836 .handler
= &ftdi_handle_device_desc_command
,
837 .mode
= COMMAND_CONFIG
,
838 .help
= "set the USB device description of the FTDI device",
839 .usage
= "description_string",
842 .name
= "ftdi_serial",
843 .handler
= &ftdi_handle_serial_command
,
844 .mode
= COMMAND_CONFIG
,
845 .help
= "set the serial number of the FTDI device",
846 .usage
= "serial_string",
849 .name
= "ftdi_channel",
850 .handler
= &ftdi_handle_channel_command
,
851 .mode
= COMMAND_CONFIG
,
852 .help
= "set the channel of the FTDI device that is used as JTAG",
856 .name
= "ftdi_layout_init",
857 .handler
= &ftdi_handle_layout_init_command
,
858 .mode
= COMMAND_CONFIG
,
859 .help
= "initialize the FTDI GPIO signals used "
860 "to control output-enables and reset signals",
861 .usage
= "data direction",
864 .name
= "ftdi_layout_signal",
865 .handler
= &ftdi_handle_layout_signal_command
,
867 .help
= "define a signal controlled by one or more FTDI GPIO as data "
868 "and/or output enable",
869 .usage
= "name [-data mask|-ndata mask] [-oe mask|-noe mask] [-alias|-nalias name]",
872 .name
= "ftdi_set_signal",
873 .handler
= &ftdi_handle_set_signal_command
,
874 .mode
= COMMAND_EXEC
,
875 .help
= "control a layout-specific signal",
876 .usage
= "name (1|0|z)",
879 .name
= "ftdi_vid_pid",
880 .handler
= &ftdi_handle_vid_pid_command
,
881 .mode
= COMMAND_CONFIG
,
882 .help
= "the vendor ID and product ID of the FTDI device",
883 .usage
= "(vid pid)* ",
885 COMMAND_REGISTRATION_DONE
888 static int create_default_signal(const char *name
, uint16_t data_mask
)
890 struct signal
*sig
= create_signal(name
);
892 LOG_ERROR("failed to create signal %s", name
);
895 sig
->invert_data
= false;
896 sig
->data_mask
= data_mask
;
897 sig
->invert_oe
= false;
903 static int create_signals(void)
905 if (create_default_signal("TCK", 0x01) != ERROR_OK
)
907 if (create_default_signal("TDI", 0x02) != ERROR_OK
)
909 if (create_default_signal("TDO", 0x04) != ERROR_OK
)
911 if (create_default_signal("TMS", 0x08) != ERROR_OK
)
916 static int ftdi_swd_init(void)
918 LOG_INFO("FTDI SWD mode enabled");
921 if (create_signals() != ERROR_OK
)
924 swd_cmd_queue_alloced
= 10;
925 swd_cmd_queue
= malloc(swd_cmd_queue_alloced
* sizeof(*swd_cmd_queue
));
927 return swd_cmd_queue
!= NULL
? ERROR_OK
: ERROR_FAIL
;
930 static void ftdi_swd_swdio_en(bool enable
)
932 struct signal
*oe
= find_signal_by_name("SWDIO_OE");
934 ftdi_set_signal(oe
, enable
? '1' : '0');
938 * Flush the MPSSE queue and process the SWD transaction queue
942 static int ftdi_swd_run_queue(struct adiv5_dap
*dap
)
944 LOG_DEBUG("Executing %zu queued transactions", swd_cmd_queue_length
);
946 struct signal
*led
= find_signal_by_name("LED");
948 if (queued_retval
!= ERROR_OK
) {
949 LOG_DEBUG("Skipping due to previous errors: %d", queued_retval
);
953 /* A transaction must be followed by another transaction or at least 8 idle cycles to
954 * ensure that data is clocked through the AP. */
955 mpsse_clock_data_out(mpsse_ctx
, NULL
, 0, 8, SWD_MODE
);
957 /* Terminate the "blink", if the current layout has that feature */
959 ftdi_set_signal(led
, '0');
961 queued_retval
= mpsse_flush(mpsse_ctx
);
962 if (queued_retval
!= ERROR_OK
) {
963 LOG_ERROR("MPSSE failed");
967 for (size_t i
= 0; i
< swd_cmd_queue_length
; i
++) {
968 int ack
= buf_get_u32(&swd_cmd_queue
[i
].trn_ack_data_parity_trn
, 1, 3);
970 LOG_DEBUG("%s %s %s reg %X = %08"PRIx32
,
971 ack
== SWD_ACK_OK
? "OK" : ack
== SWD_ACK_WAIT
? "WAIT" : ack
== SWD_ACK_FAULT
? "FAULT" : "JUNK",
972 swd_cmd_queue
[i
].cmd
& SWD_CMD_APnDP
? "AP" : "DP",
973 swd_cmd_queue
[i
].cmd
& SWD_CMD_RnW
? "read" : "write",
974 (swd_cmd_queue
[i
].cmd
& SWD_CMD_A32
) >> 1,
975 buf_get_u32(swd_cmd_queue
[i
].trn_ack_data_parity_trn
,
976 1 + 3 + (swd_cmd_queue
[i
].cmd
& SWD_CMD_RnW
? 0 : 1), 32));
978 if (ack
!= SWD_ACK_OK
) {
979 queued_retval
= ack
== SWD_ACK_WAIT
? ERROR_WAIT
: ERROR_FAIL
;
982 } else if (swd_cmd_queue
[i
].cmd
& SWD_CMD_RnW
) {
983 uint32_t data
= buf_get_u32(swd_cmd_queue
[i
].trn_ack_data_parity_trn
, 1 + 3, 32);
984 int parity
= buf_get_u32(swd_cmd_queue
[i
].trn_ack_data_parity_trn
, 1 + 3 + 32, 1);
986 if (parity
!= parity_u32(data
)) {
987 LOG_ERROR("SWD Read data parity mismatch");
988 queued_retval
= ERROR_FAIL
;
992 if (swd_cmd_queue
[i
].dst
!= NULL
)
993 *swd_cmd_queue
[i
].dst
= data
;
998 swd_cmd_queue_length
= 0;
999 retval
= queued_retval
;
1000 queued_retval
= ERROR_OK
;
1002 /* Queue a new "blink" */
1003 if (led
&& retval
== ERROR_OK
)
1004 ftdi_set_signal(led
, '1');
1009 static void ftdi_swd_queue_cmd(struct adiv5_dap
*dap
, uint8_t cmd
, uint32_t *dst
, uint32_t data
)
1011 if (swd_cmd_queue_length
>= swd_cmd_queue_alloced
) {
1012 /* Not enough room in the queue. Run the queue and increase its size for next time.
1013 * Note that it's not possible to avoid running the queue here, because mpsse contains
1014 * pointers into the queue which may be invalid after the realloc. */
1015 queued_retval
= ftdi_swd_run_queue(dap
);
1016 struct swd_cmd_queue_entry
*q
= realloc(swd_cmd_queue
, swd_cmd_queue_alloced
* 2 * sizeof(*swd_cmd_queue
));
1019 swd_cmd_queue_alloced
*= 2;
1020 LOG_DEBUG("Increased SWD command queue to %zu elements", swd_cmd_queue_alloced
);
1024 if (queued_retval
!= ERROR_OK
)
1027 size_t i
= swd_cmd_queue_length
++;
1028 swd_cmd_queue
[i
].cmd
= cmd
| SWD_CMD_START
| SWD_CMD_PARK
;
1030 mpsse_clock_data_out(mpsse_ctx
, &swd_cmd_queue
[i
].cmd
, 0, 8, SWD_MODE
);
1032 if (swd_cmd_queue
[i
].cmd
& SWD_CMD_RnW
) {
1033 /* Queue a read transaction */
1034 swd_cmd_queue
[i
].dst
= dst
;
1036 ftdi_swd_swdio_en(false);
1037 mpsse_clock_data_in(mpsse_ctx
, swd_cmd_queue
[i
].trn_ack_data_parity_trn
,
1038 0, 1 + 3 + 32 + 1 + 1, SWD_MODE
);
1039 ftdi_swd_swdio_en(true);
1041 /* Queue a write transaction */
1042 ftdi_swd_swdio_en(false);
1044 mpsse_clock_data_in(mpsse_ctx
, swd_cmd_queue
[i
].trn_ack_data_parity_trn
,
1045 0, 1 + 3 + 1, SWD_MODE
);
1047 ftdi_swd_swdio_en(true);
1049 buf_set_u32(swd_cmd_queue
[i
].trn_ack_data_parity_trn
, 1 + 3 + 1, 32, data
);
1050 buf_set_u32(swd_cmd_queue
[i
].trn_ack_data_parity_trn
, 1 + 3 + 1 + 32, 1, parity_u32(data
));
1052 mpsse_clock_data_out(mpsse_ctx
, swd_cmd_queue
[i
].trn_ack_data_parity_trn
,
1053 1 + 3 + 1, 32 + 1, SWD_MODE
);
1056 /* Insert idle cycles after AP accesses to avoid WAIT */
1057 if (cmd
& SWD_CMD_APnDP
)
1058 mpsse_clock_data_out(mpsse_ctx
, NULL
, 0, dap
->memaccess_tck
, SWD_MODE
);
1062 static void ftdi_swd_read_reg(struct adiv5_dap
*dap
, uint8_t cmd
, uint32_t *value
)
1064 assert(cmd
& SWD_CMD_RnW
);
1065 ftdi_swd_queue_cmd(dap
, cmd
, value
, 0);
1068 static void ftdi_swd_write_reg(struct adiv5_dap
*dap
, uint8_t cmd
, uint32_t value
)
1070 assert(!(cmd
& SWD_CMD_RnW
));
1071 ftdi_swd_queue_cmd(dap
, cmd
, NULL
, value
);
1074 static int_least32_t ftdi_swd_frequency(struct adiv5_dap
*dap
, int_least32_t hz
)
1077 freq
= mpsse_set_frequency(mpsse_ctx
, hz
);
1082 static int ftdi_swd_switch_seq(struct adiv5_dap
*dap
, enum swd_special_seq seq
)
1086 LOG_DEBUG("SWD line reset");
1087 mpsse_clock_data_out(mpsse_ctx
, swd_seq_line_reset
, 0, swd_seq_line_reset_len
, SWD_MODE
);
1090 LOG_DEBUG("JTAG-to-SWD");
1091 mpsse_clock_data_out(mpsse_ctx
, swd_seq_jtag_to_swd
, 0, swd_seq_jtag_to_swd_len
, SWD_MODE
);
1094 LOG_DEBUG("SWD-to-JTAG");
1095 mpsse_clock_data_out(mpsse_ctx
, swd_seq_swd_to_jtag
, 0, swd_seq_swd_to_jtag_len
, SWD_MODE
);
1098 LOG_ERROR("Sequence %d not supported", seq
);
1105 static const struct swd_driver ftdi_swd
= {
1106 .init
= ftdi_swd_init
,
1107 .frequency
= ftdi_swd_frequency
,
1108 .switch_seq
= ftdi_swd_switch_seq
,
1109 .read_reg
= ftdi_swd_read_reg
,
1110 .write_reg
= ftdi_swd_write_reg
,
1111 .run
= ftdi_swd_run_queue
,
1114 static const char * const ftdi_transports
[] = { "jtag", "swd", NULL
};
1116 struct jtag_interface ftdi_interface
= {
1118 .supported
= DEBUG_CAP_TMS_SEQ
,
1119 .commands
= ftdi_command_handlers
,
1120 .transports
= ftdi_transports
,
1123 .init
= ftdi_initialize
,
1125 .speed
= ftdi_speed
,
1126 .speed_div
= ftdi_speed_div
,
1128 .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)