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
);
670 COMMAND_HANDLER(ftdi_handle_device_desc_command
)
673 if (ftdi_device_desc
)
674 free(ftdi_device_desc
);
675 ftdi_device_desc
= strdup(CMD_ARGV
[0]);
677 LOG_ERROR("expected exactly one argument to ftdi_device_desc <description>");
683 COMMAND_HANDLER(ftdi_handle_serial_command
)
688 ftdi_serial
= strdup(CMD_ARGV
[0]);
690 return ERROR_COMMAND_SYNTAX_ERROR
;
696 COMMAND_HANDLER(ftdi_handle_channel_command
)
699 COMMAND_PARSE_NUMBER(u8
, CMD_ARGV
[0], ftdi_channel
);
701 return ERROR_COMMAND_SYNTAX_ERROR
;
706 COMMAND_HANDLER(ftdi_handle_layout_init_command
)
709 return ERROR_COMMAND_SYNTAX_ERROR
;
711 COMMAND_PARSE_NUMBER(u16
, CMD_ARGV
[0], jtag_output_init
);
712 COMMAND_PARSE_NUMBER(u16
, CMD_ARGV
[1], jtag_direction_init
);
717 COMMAND_HANDLER(ftdi_handle_layout_signal_command
)
720 return ERROR_COMMAND_SYNTAX_ERROR
;
722 bool invert_data
= false;
723 uint16_t data_mask
= 0;
724 bool invert_oe
= false;
725 uint16_t oe_mask
= 0;
726 for (unsigned i
= 1; i
< CMD_ARGC
; i
+= 2) {
727 if (strcmp("-data", CMD_ARGV
[i
]) == 0) {
729 COMMAND_PARSE_NUMBER(u16
, CMD_ARGV
[i
+ 1], data_mask
);
730 } else if (strcmp("-ndata", CMD_ARGV
[i
]) == 0) {
732 COMMAND_PARSE_NUMBER(u16
, CMD_ARGV
[i
+ 1], data_mask
);
733 } else if (strcmp("-oe", CMD_ARGV
[i
]) == 0) {
735 COMMAND_PARSE_NUMBER(u16
, CMD_ARGV
[i
+ 1], oe_mask
);
736 } else if (strcmp("-noe", CMD_ARGV
[i
]) == 0) {
738 COMMAND_PARSE_NUMBER(u16
, CMD_ARGV
[i
+ 1], oe_mask
);
739 } else if (!strcmp("-alias", CMD_ARGV
[i
]) ||
740 !strcmp("-nalias", CMD_ARGV
[i
])) {
741 if (!strcmp("-nalias", CMD_ARGV
[i
]))
743 struct signal
*sig
= find_signal_by_name(CMD_ARGV
[i
+ 1]);
745 LOG_ERROR("signal %s is not defined", CMD_ARGV
[i
+ 1]);
748 data_mask
= sig
->data_mask
;
749 oe_mask
= sig
->oe_mask
;
750 invert_oe
= sig
->invert_oe
;
751 invert_data
^= sig
->invert_data
;
753 LOG_ERROR("unknown option '%s'", CMD_ARGV
[i
]);
754 return ERROR_COMMAND_SYNTAX_ERROR
;
759 sig
= find_signal_by_name(CMD_ARGV
[0]);
761 sig
= create_signal(CMD_ARGV
[0]);
763 LOG_ERROR("failed to create signal %s", CMD_ARGV
[0]);
767 sig
->invert_data
= invert_data
;
768 sig
->data_mask
= data_mask
;
769 sig
->invert_oe
= invert_oe
;
770 sig
->oe_mask
= oe_mask
;
775 COMMAND_HANDLER(ftdi_handle_set_signal_command
)
778 return ERROR_COMMAND_SYNTAX_ERROR
;
781 sig
= find_signal_by_name(CMD_ARGV
[0]);
783 LOG_ERROR("interface configuration doesn't define signal '%s'", CMD_ARGV
[0]);
787 switch (*CMD_ARGV
[1]) {
792 /* single character level specifier only */
793 if (CMD_ARGV
[1][1] == '\0') {
794 ftdi_set_signal(sig
, *CMD_ARGV
[1]);
798 LOG_ERROR("unknown signal level '%s', use 0, 1 or z", CMD_ARGV
[1]);
799 return ERROR_COMMAND_SYNTAX_ERROR
;
802 return mpsse_flush(mpsse_ctx
);
805 COMMAND_HANDLER(ftdi_handle_vid_pid_command
)
807 if (CMD_ARGC
> MAX_USB_IDS
* 2) {
808 LOG_WARNING("ignoring extra IDs in ftdi_vid_pid "
809 "(maximum is %d pairs)", MAX_USB_IDS
);
810 CMD_ARGC
= MAX_USB_IDS
* 2;
812 if (CMD_ARGC
< 2 || (CMD_ARGC
& 1)) {
813 LOG_WARNING("incomplete ftdi_vid_pid configuration directive");
815 return ERROR_COMMAND_SYNTAX_ERROR
;
816 /* remove the incomplete trailing id */
821 for (i
= 0; i
< CMD_ARGC
; i
+= 2) {
822 COMMAND_PARSE_NUMBER(u16
, CMD_ARGV
[i
], ftdi_vid
[i
>> 1]);
823 COMMAND_PARSE_NUMBER(u16
, CMD_ARGV
[i
+ 1], ftdi_pid
[i
>> 1]);
827 * Explicitly terminate, in case there are multiples instances of
830 ftdi_vid
[i
>> 1] = ftdi_pid
[i
>> 1] = 0;
835 static const struct command_registration ftdi_command_handlers
[] = {
837 .name
= "ftdi_device_desc",
838 .handler
= &ftdi_handle_device_desc_command
,
839 .mode
= COMMAND_CONFIG
,
840 .help
= "set the USB device description of the FTDI device",
841 .usage
= "description_string",
844 .name
= "ftdi_serial",
845 .handler
= &ftdi_handle_serial_command
,
846 .mode
= COMMAND_CONFIG
,
847 .help
= "set the serial number of the FTDI device",
848 .usage
= "serial_string",
851 .name
= "ftdi_channel",
852 .handler
= &ftdi_handle_channel_command
,
853 .mode
= COMMAND_CONFIG
,
854 .help
= "set the channel of the FTDI device that is used as JTAG",
858 .name
= "ftdi_layout_init",
859 .handler
= &ftdi_handle_layout_init_command
,
860 .mode
= COMMAND_CONFIG
,
861 .help
= "initialize the FTDI GPIO signals used "
862 "to control output-enables and reset signals",
863 .usage
= "data direction",
866 .name
= "ftdi_layout_signal",
867 .handler
= &ftdi_handle_layout_signal_command
,
869 .help
= "define a signal controlled by one or more FTDI GPIO as data "
870 "and/or output enable",
871 .usage
= "name [-data mask|-ndata mask] [-oe mask|-noe mask] [-alias|-nalias name]",
874 .name
= "ftdi_set_signal",
875 .handler
= &ftdi_handle_set_signal_command
,
876 .mode
= COMMAND_EXEC
,
877 .help
= "control a layout-specific signal",
878 .usage
= "name (1|0|z)",
881 .name
= "ftdi_vid_pid",
882 .handler
= &ftdi_handle_vid_pid_command
,
883 .mode
= COMMAND_CONFIG
,
884 .help
= "the vendor ID and product ID of the FTDI device",
885 .usage
= "(vid pid)* ",
887 COMMAND_REGISTRATION_DONE
890 static int create_default_signal(const char *name
, uint16_t data_mask
)
892 struct signal
*sig
= create_signal(name
);
894 LOG_ERROR("failed to create signal %s", name
);
897 sig
->invert_data
= false;
898 sig
->data_mask
= data_mask
;
899 sig
->invert_oe
= false;
905 static int create_signals(void)
907 if (create_default_signal("TCK", 0x01) != ERROR_OK
)
909 if (create_default_signal("TDI", 0x02) != ERROR_OK
)
911 if (create_default_signal("TDO", 0x04) != ERROR_OK
)
913 if (create_default_signal("TMS", 0x08) != ERROR_OK
)
918 static int ftdi_swd_init(void)
920 LOG_INFO("FTDI SWD mode enabled");
923 if (create_signals() != ERROR_OK
)
926 swd_cmd_queue_alloced
= 10;
927 swd_cmd_queue
= malloc(swd_cmd_queue_alloced
* sizeof(*swd_cmd_queue
));
929 return swd_cmd_queue
!= NULL
? ERROR_OK
: ERROR_FAIL
;
932 static void ftdi_swd_swdio_en(bool enable
)
934 struct signal
*oe
= find_signal_by_name("SWDIO_OE");
936 ftdi_set_signal(oe
, enable
? '1' : '0');
940 * Flush the MPSSE queue and process the SWD transaction queue
944 static int ftdi_swd_run_queue(struct adiv5_dap
*dap
)
946 LOG_DEBUG("Executing %zu queued transactions", swd_cmd_queue_length
);
948 struct signal
*led
= find_signal_by_name("LED");
950 if (queued_retval
!= ERROR_OK
) {
951 LOG_DEBUG("Skipping due to previous errors: %d", queued_retval
);
955 /* A transaction must be followed by another transaction or at least 8 idle cycles to
956 * ensure that data is clocked through the AP. */
957 mpsse_clock_data_out(mpsse_ctx
, NULL
, 0, 8, SWD_MODE
);
959 /* Terminate the "blink", if the current layout has that feature */
961 ftdi_set_signal(led
, '0');
963 queued_retval
= mpsse_flush(mpsse_ctx
);
964 if (queued_retval
!= ERROR_OK
) {
965 LOG_ERROR("MPSSE failed");
969 for (size_t i
= 0; i
< swd_cmd_queue_length
; i
++) {
970 int ack
= buf_get_u32(swd_cmd_queue
[i
].trn_ack_data_parity_trn
, 1, 3);
972 LOG_DEBUG("%s %s %s reg %X = %08"PRIx32
,
973 ack
== SWD_ACK_OK
? "OK" : ack
== SWD_ACK_WAIT
? "WAIT" : ack
== SWD_ACK_FAULT
? "FAULT" : "JUNK",
974 swd_cmd_queue
[i
].cmd
& SWD_CMD_APnDP
? "AP" : "DP",
975 swd_cmd_queue
[i
].cmd
& SWD_CMD_RnW
? "read" : "write",
976 (swd_cmd_queue
[i
].cmd
& SWD_CMD_A32
) >> 1,
977 buf_get_u32(swd_cmd_queue
[i
].trn_ack_data_parity_trn
,
978 1 + 3 + (swd_cmd_queue
[i
].cmd
& SWD_CMD_RnW
? 0 : 1), 32));
980 if (ack
!= SWD_ACK_OK
) {
981 queued_retval
= ack
== SWD_ACK_WAIT
? ERROR_WAIT
: ERROR_FAIL
;
984 } else if (swd_cmd_queue
[i
].cmd
& SWD_CMD_RnW
) {
985 uint32_t data
= buf_get_u32(swd_cmd_queue
[i
].trn_ack_data_parity_trn
, 1 + 3, 32);
986 int parity
= buf_get_u32(swd_cmd_queue
[i
].trn_ack_data_parity_trn
, 1 + 3 + 32, 1);
988 if (parity
!= parity_u32(data
)) {
989 LOG_ERROR("SWD Read data parity mismatch");
990 queued_retval
= ERROR_FAIL
;
994 if (swd_cmd_queue
[i
].dst
!= NULL
)
995 *swd_cmd_queue
[i
].dst
= data
;
1000 swd_cmd_queue_length
= 0;
1001 retval
= queued_retval
;
1002 queued_retval
= ERROR_OK
;
1004 /* Queue a new "blink" */
1005 if (led
&& retval
== ERROR_OK
)
1006 ftdi_set_signal(led
, '1');
1011 static void ftdi_swd_queue_cmd(struct adiv5_dap
*dap
, uint8_t cmd
, uint32_t *dst
, uint32_t data
)
1013 if (swd_cmd_queue_length
>= swd_cmd_queue_alloced
) {
1014 /* Not enough room in the queue. Run the queue and increase its size for next time.
1015 * Note that it's not possible to avoid running the queue here, because mpsse contains
1016 * pointers into the queue which may be invalid after the realloc. */
1017 queued_retval
= ftdi_swd_run_queue(dap
);
1018 struct swd_cmd_queue_entry
*q
= realloc(swd_cmd_queue
, swd_cmd_queue_alloced
* 2 * sizeof(*swd_cmd_queue
));
1021 swd_cmd_queue_alloced
*= 2;
1022 LOG_DEBUG("Increased SWD command queue to %zu elements", swd_cmd_queue_alloced
);
1026 if (queued_retval
!= ERROR_OK
)
1029 size_t i
= swd_cmd_queue_length
++;
1030 swd_cmd_queue
[i
].cmd
= cmd
| SWD_CMD_START
| SWD_CMD_PARK
;
1032 mpsse_clock_data_out(mpsse_ctx
, &swd_cmd_queue
[i
].cmd
, 0, 8, SWD_MODE
);
1034 if (swd_cmd_queue
[i
].cmd
& SWD_CMD_RnW
) {
1035 /* Queue a read transaction */
1036 swd_cmd_queue
[i
].dst
= dst
;
1038 ftdi_swd_swdio_en(false);
1039 mpsse_clock_data_in(mpsse_ctx
, swd_cmd_queue
[i
].trn_ack_data_parity_trn
,
1040 0, 1 + 3 + 32 + 1 + 1, SWD_MODE
);
1041 ftdi_swd_swdio_en(true);
1043 /* Queue a write transaction */
1044 ftdi_swd_swdio_en(false);
1046 mpsse_clock_data_in(mpsse_ctx
, swd_cmd_queue
[i
].trn_ack_data_parity_trn
,
1047 0, 1 + 3 + 1, SWD_MODE
);
1049 ftdi_swd_swdio_en(true);
1051 buf_set_u32(swd_cmd_queue
[i
].trn_ack_data_parity_trn
, 1 + 3 + 1, 32, data
);
1052 buf_set_u32(swd_cmd_queue
[i
].trn_ack_data_parity_trn
, 1 + 3 + 1 + 32, 1, parity_u32(data
));
1054 mpsse_clock_data_out(mpsse_ctx
, swd_cmd_queue
[i
].trn_ack_data_parity_trn
,
1055 1 + 3 + 1, 32 + 1, SWD_MODE
);
1058 /* Insert idle cycles after AP accesses to avoid WAIT */
1059 if (cmd
& SWD_CMD_APnDP
)
1060 mpsse_clock_data_out(mpsse_ctx
, NULL
, 0, dap
->memaccess_tck
, SWD_MODE
);
1064 static void ftdi_swd_read_reg(struct adiv5_dap
*dap
, uint8_t cmd
, uint32_t *value
)
1066 assert(cmd
& SWD_CMD_RnW
);
1067 ftdi_swd_queue_cmd(dap
, cmd
, value
, 0);
1070 static void ftdi_swd_write_reg(struct adiv5_dap
*dap
, uint8_t cmd
, uint32_t value
)
1072 assert(!(cmd
& SWD_CMD_RnW
));
1073 ftdi_swd_queue_cmd(dap
, cmd
, NULL
, value
);
1076 static int_least32_t ftdi_swd_frequency(struct adiv5_dap
*dap
, int_least32_t hz
)
1079 freq
= mpsse_set_frequency(mpsse_ctx
, hz
);
1084 static int ftdi_swd_switch_seq(struct adiv5_dap
*dap
, enum swd_special_seq seq
)
1088 LOG_DEBUG("SWD line reset");
1089 mpsse_clock_data_out(mpsse_ctx
, swd_seq_line_reset
, 0, swd_seq_line_reset_len
, SWD_MODE
);
1092 LOG_DEBUG("JTAG-to-SWD");
1093 mpsse_clock_data_out(mpsse_ctx
, swd_seq_jtag_to_swd
, 0, swd_seq_jtag_to_swd_len
, SWD_MODE
);
1096 LOG_DEBUG("SWD-to-JTAG");
1097 mpsse_clock_data_out(mpsse_ctx
, swd_seq_swd_to_jtag
, 0, swd_seq_swd_to_jtag_len
, SWD_MODE
);
1100 LOG_ERROR("Sequence %d not supported", seq
);
1107 static const struct swd_driver ftdi_swd
= {
1108 .init
= ftdi_swd_init
,
1109 .frequency
= ftdi_swd_frequency
,
1110 .switch_seq
= ftdi_swd_switch_seq
,
1111 .read_reg
= ftdi_swd_read_reg
,
1112 .write_reg
= ftdi_swd_write_reg
,
1113 .run
= ftdi_swd_run_queue
,
1116 static const char * const ftdi_transports
[] = { "jtag", "swd", NULL
};
1118 struct jtag_interface ftdi_interface
= {
1120 .supported
= DEBUG_CAP_TMS_SEQ
,
1121 .commands
= ftdi_command_handlers
,
1122 .transports
= ftdi_transports
,
1125 .init
= ftdi_initialize
,
1127 .speed
= ftdi_speed
,
1128 .speed_div
= ftdi_speed_div
,
1130 .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)