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, see <http://www.gnu.org/licenses/>. *
17 ***************************************************************************/
21 * JTAG adapters based on the FT2232 full and high speed USB parts are
22 * popular low cost JTAG debug solutions. Many FT2232 based JTAG adapters
23 * are discrete, but development boards may integrate them as alternatives
24 * to more capable (and expensive) third party JTAG pods.
26 * JTAG uses only one of the two communications channels ("MPSSE engines")
27 * on these devices. Adapters based on FT4232 parts have four ports/channels
28 * (A/B/C/D), instead of just two (A/B).
30 * Especially on development boards integrating one of these chips (as
31 * opposed to discrete pods/dongles), the additional channels can be used
32 * for a variety of purposes, but OpenOCD only uses one channel at a time.
34 * - As a USB-to-serial adapter for the target's console UART ...
35 * which may be able to support ROM boot loaders that load initial
36 * firmware images to flash (or SRAM).
38 * - On systems which support ARM's SWD in addition to JTAG, or instead
39 * of it, that second port can be used for reading SWV/SWO trace data.
41 * - Additional JTAG links, e.g. to a CPLD or * FPGA.
43 * FT2232 based JTAG adapters are "dumb" not "smart", because most JTAG
44 * request/response interactions involve round trips over the USB link.
45 * A "smart" JTAG adapter has intelligence close to the scan chain, so it
46 * can for example poll quickly for a status change (usually taking on the
47 * order of microseconds not milliseconds) before beginning a queued
48 * transaction which require the previous one to have completed.
50 * There are dozens of adapters of this type, differing in details which
51 * this driver needs to understand. Those "layout" details are required
52 * as part of FT2232 driver configuration.
54 * This code uses information contained in the MPSSE specification which was
56 * http://www.ftdichip.com/Documents/AppNotes/AN2232C-01_MPSSE_Cmnd.pdf
57 * Hereafter this is called the "MPSSE Spec".
59 * The datasheet for the ftdichip.com's FT2232D part is here:
60 * http://www.ftdichip.com/Documents/DataSheets/DS_FT2232D.pdf
62 * Also note the issue with code 0x4b (clock data to TMS) noted in
63 * http://developer.intra2net.com/mailarchive/html/libftdi/2009/msg00292.html
64 * which can affect longer JTAG state paths.
71 /* project specific includes */
72 #include <jtag/interface.h>
74 #include <transport/transport.h>
75 #include <helper/time_support.h>
83 /* FTDI access library includes */
86 #define JTAG_MODE (LSB_FIRST | POS_EDGE_IN | NEG_EDGE_OUT)
87 #define JTAG_MODE_ALT (LSB_FIRST | NEG_EDGE_IN | NEG_EDGE_OUT)
88 #define SWD_MODE (LSB_FIRST | POS_EDGE_IN | NEG_EDGE_OUT)
90 static char *ftdi_device_desc
;
91 static char *ftdi_serial
;
92 static char *ftdi_location
;
93 static uint8_t ftdi_channel
;
94 static uint8_t ftdi_jtag_mode
= JTAG_MODE
;
99 /* vid = pid = 0 marks the end of the list */
100 static uint16_t ftdi_vid
[MAX_USB_IDS
+ 1] = { 0 };
101 static uint16_t ftdi_pid
[MAX_USB_IDS
+ 1] = { 0 };
103 static struct mpsse_ctx
*mpsse_ctx
;
114 static struct signal
*signals
;
116 /* FIXME: Where to store per-instance data? We need an SWD context. */
117 static struct swd_cmd_queue_entry
{
120 uint8_t trn_ack_data_parity_trn
[DIV_ROUND_UP(4 + 3 + 32 + 1 + 4, 8)];
122 static size_t swd_cmd_queue_length
;
123 static size_t swd_cmd_queue_alloced
;
124 static int queued_retval
;
127 static uint16_t output
;
128 static uint16_t direction
;
129 static uint16_t jtag_output_init
;
130 static uint16_t jtag_direction_init
;
132 static int ftdi_swd_switch_seq(enum swd_special_seq seq
);
134 static struct signal
*find_signal_by_name(const char *name
)
136 for (struct signal
*sig
= signals
; sig
; sig
= sig
->next
) {
137 if (strcmp(name
, sig
->name
) == 0)
143 static struct signal
*create_signal(const char *name
)
145 struct signal
**psig
= &signals
;
147 psig
= &(*psig
)->next
;
149 *psig
= calloc(1, sizeof(**psig
));
153 (*psig
)->name
= strdup(name
);
154 if ((*psig
)->name
== NULL
) {
161 static int ftdi_set_signal(const struct signal
*s
, char value
)
166 if (s
->data_mask
== 0 && s
->oe_mask
== 0) {
167 LOG_ERROR("interface doesn't provide signal '%s'", s
->name
);
172 data
= s
->invert_data
;
176 if (s
->data_mask
== 0) {
177 LOG_ERROR("interface can't drive '%s' high", s
->name
);
180 data
= !s
->invert_data
;
185 if (s
->oe_mask
== 0) {
186 LOG_ERROR("interface can't tri-state '%s'", s
->name
);
189 data
= s
->invert_data
;
193 assert(0 && "invalid signal level specifier");
197 uint16_t old_output
= output
;
198 uint16_t old_direction
= direction
;
200 output
= data
? output
| s
->data_mask
: output
& ~s
->data_mask
;
201 if (s
->oe_mask
== s
->data_mask
)
202 direction
= oe
? direction
| s
->oe_mask
: direction
& ~s
->oe_mask
;
204 output
= oe
? output
| s
->oe_mask
: output
& ~s
->oe_mask
;
206 if ((output
& 0xff) != (old_output
& 0xff) || (direction
& 0xff) != (old_direction
& 0xff))
207 mpsse_set_data_bits_low_byte(mpsse_ctx
, output
& 0xff, direction
& 0xff);
208 if ((output
>> 8 != old_output
>> 8) || (direction
>> 8 != old_direction
>> 8))
209 mpsse_set_data_bits_high_byte(mpsse_ctx
, output
>> 8, direction
>> 8);
216 * Function move_to_state
217 * moves the TAP controller from the current state to a
218 * \a goal_state through a path given by tap_get_tms_path(). State transition
219 * logging is performed by delegation to clock_tms().
221 * @param goal_state is the destination state for the move.
223 static void move_to_state(tap_state_t goal_state
)
225 tap_state_t start_state
= tap_get_state();
227 /* goal_state is 1/2 of a tuple/pair of states which allow convenient
228 lookup of the required TMS pattern to move to this state from the
232 /* do the 2 lookups */
233 uint8_t tms_bits
= tap_get_tms_path(start_state
, goal_state
);
234 int tms_count
= tap_get_tms_path_len(start_state
, goal_state
);
235 assert(tms_count
<= 8);
237 DEBUG_JTAG_IO("start=%s goal=%s", tap_state_name(start_state
), tap_state_name(goal_state
));
239 /* Track state transitions step by step */
240 for (int i
= 0; i
< tms_count
; i
++)
241 tap_set_state(tap_state_transition(tap_get_state(), (tms_bits
>> i
) & 1));
243 mpsse_clock_tms_cs_out(mpsse_ctx
,
251 static int ftdi_speed(int speed
)
254 retval
= mpsse_set_frequency(mpsse_ctx
, speed
);
257 LOG_ERROR("couldn't set FTDI TCK speed");
261 if (!swd_mode
&& speed
>= 10000000 && ftdi_jtag_mode
!= JTAG_MODE_ALT
)
262 LOG_INFO("ftdi: if you experience problems at higher adapter clocks, try "
263 "the command \"ftdi_tdo_sample_edge falling\"");
267 static int ftdi_speed_div(int speed
, int *khz
)
273 static int ftdi_khz(int khz
, int *jtag_speed
)
275 if (khz
== 0 && !mpsse_is_high_speed(mpsse_ctx
)) {
276 LOG_DEBUG("RCLK not supported");
280 *jtag_speed
= khz
* 1000;
284 static void ftdi_end_state(tap_state_t state
)
286 if (tap_is_state_stable(state
))
287 tap_set_end_state(state
);
289 LOG_ERROR("BUG: %s is not a stable end state", tap_state_name(state
));
294 static void ftdi_execute_runtest(struct jtag_command
*cmd
)
299 DEBUG_JTAG_IO("runtest %i cycles, end in %s",
300 cmd
->cmd
.runtest
->num_cycles
,
301 tap_state_name(cmd
->cmd
.runtest
->end_state
));
303 if (tap_get_state() != TAP_IDLE
)
304 move_to_state(TAP_IDLE
);
306 /* TODO: Reuse ftdi_execute_stableclocks */
307 i
= cmd
->cmd
.runtest
->num_cycles
;
309 /* there are no state transitions in this code, so omit state tracking */
310 unsigned this_len
= i
> 7 ? 7 : i
;
311 mpsse_clock_tms_cs_out(mpsse_ctx
, &zero
, 0, this_len
, false, ftdi_jtag_mode
);
315 ftdi_end_state(cmd
->cmd
.runtest
->end_state
);
317 if (tap_get_state() != tap_get_end_state())
318 move_to_state(tap_get_end_state());
320 DEBUG_JTAG_IO("runtest: %i, end in %s",
321 cmd
->cmd
.runtest
->num_cycles
,
322 tap_state_name(tap_get_end_state()));
325 static void ftdi_execute_statemove(struct jtag_command
*cmd
)
327 DEBUG_JTAG_IO("statemove end in %s",
328 tap_state_name(cmd
->cmd
.statemove
->end_state
));
330 ftdi_end_state(cmd
->cmd
.statemove
->end_state
);
332 /* shortest-path move to desired end state */
333 if (tap_get_state() != tap_get_end_state() || tap_get_end_state() == TAP_RESET
)
334 move_to_state(tap_get_end_state());
338 * Clock a bunch of TMS (or SWDIO) transitions, to change the JTAG
339 * (or SWD) state machine. REVISIT: Not the best method, perhaps.
341 static void ftdi_execute_tms(struct jtag_command
*cmd
)
343 DEBUG_JTAG_IO("TMS: %d bits", cmd
->cmd
.tms
->num_bits
);
345 /* TODO: Missing tap state tracking, also missing from ft2232.c! */
346 mpsse_clock_tms_cs_out(mpsse_ctx
,
349 cmd
->cmd
.tms
->num_bits
,
354 static void ftdi_execute_pathmove(struct jtag_command
*cmd
)
356 tap_state_t
*path
= cmd
->cmd
.pathmove
->path
;
357 int num_states
= cmd
->cmd
.pathmove
->num_states
;
359 DEBUG_JTAG_IO("pathmove: %i states, current: %s end: %s", num_states
,
360 tap_state_name(tap_get_state()),
361 tap_state_name(path
[num_states
-1]));
364 unsigned bit_count
= 0;
365 uint8_t tms_byte
= 0;
369 /* this loop verifies that the path is legal and logs each state in the path */
370 while (num_states
--) {
372 /* either TMS=0 or TMS=1 must work ... */
373 if (tap_state_transition(tap_get_state(), false)
374 == path
[state_count
])
375 buf_set_u32(&tms_byte
, bit_count
++, 1, 0x0);
376 else if (tap_state_transition(tap_get_state(), true)
377 == path
[state_count
]) {
378 buf_set_u32(&tms_byte
, bit_count
++, 1, 0x1);
380 /* ... or else the caller goofed BADLY */
382 LOG_ERROR("BUG: %s -> %s isn't a valid "
383 "TAP state transition",
384 tap_state_name(tap_get_state()),
385 tap_state_name(path
[state_count
]));
389 tap_set_state(path
[state_count
]);
392 if (bit_count
== 7 || num_states
== 0) {
393 mpsse_clock_tms_cs_out(mpsse_ctx
,
402 tap_set_end_state(tap_get_state());
405 static void ftdi_execute_scan(struct jtag_command
*cmd
)
407 DEBUG_JTAG_IO("%s type:%d", cmd
->cmd
.scan
->ir_scan
? "IRSCAN" : "DRSCAN",
408 jtag_scan_type(cmd
->cmd
.scan
));
410 /* Make sure there are no trailing fields with num_bits == 0, or the logic below will fail. */
411 while (cmd
->cmd
.scan
->num_fields
> 0
412 && cmd
->cmd
.scan
->fields
[cmd
->cmd
.scan
->num_fields
- 1].num_bits
== 0) {
413 cmd
->cmd
.scan
->num_fields
--;
414 LOG_DEBUG("discarding trailing empty field");
417 if (cmd
->cmd
.scan
->num_fields
== 0) {
418 LOG_DEBUG("empty scan, doing nothing");
422 if (cmd
->cmd
.scan
->ir_scan
) {
423 if (tap_get_state() != TAP_IRSHIFT
)
424 move_to_state(TAP_IRSHIFT
);
426 if (tap_get_state() != TAP_DRSHIFT
)
427 move_to_state(TAP_DRSHIFT
);
430 ftdi_end_state(cmd
->cmd
.scan
->end_state
);
432 struct scan_field
*field
= cmd
->cmd
.scan
->fields
;
433 unsigned scan_size
= 0;
435 for (int i
= 0; i
< cmd
->cmd
.scan
->num_fields
; i
++, field
++) {
436 scan_size
+= field
->num_bits
;
437 DEBUG_JTAG_IO("%s%s field %d/%d %d bits",
438 field
->in_value
? "in" : "",
439 field
->out_value
? "out" : "",
441 cmd
->cmd
.scan
->num_fields
,
444 if (i
== cmd
->cmd
.scan
->num_fields
- 1 && tap_get_state() != tap_get_end_state()) {
445 /* Last field, and we're leaving IRSHIFT/DRSHIFT. Clock last bit during tap
446 * movement. This last field can't have length zero, it was checked above. */
447 mpsse_clock_data(mpsse_ctx
,
454 uint8_t last_bit
= 0;
455 if (field
->out_value
)
456 bit_copy(&last_bit
, 0, field
->out_value
, field
->num_bits
- 1, 1);
457 uint8_t tms_bits
= 0x01;
458 mpsse_clock_tms_cs(mpsse_ctx
,
466 tap_set_state(tap_state_transition(tap_get_state(), 1));
467 mpsse_clock_tms_cs_out(mpsse_ctx
,
473 tap_set_state(tap_state_transition(tap_get_state(), 0));
475 mpsse_clock_data(mpsse_ctx
,
484 if (tap_get_state() != tap_get_end_state())
485 move_to_state(tap_get_end_state());
487 DEBUG_JTAG_IO("%s scan, %i bits, end in %s",
488 (cmd
->cmd
.scan
->ir_scan
) ? "IR" : "DR", scan_size
,
489 tap_state_name(tap_get_end_state()));
492 static void ftdi_execute_reset(struct jtag_command
*cmd
)
494 DEBUG_JTAG_IO("reset trst: %i srst %i",
495 cmd
->cmd
.reset
->trst
, cmd
->cmd
.reset
->srst
);
497 if (cmd
->cmd
.reset
->trst
== 1
498 || (cmd
->cmd
.reset
->srst
499 && (jtag_get_reset_config() & RESET_SRST_PULLS_TRST
)))
500 tap_set_state(TAP_RESET
);
502 struct signal
*trst
= find_signal_by_name("nTRST");
503 if (cmd
->cmd
.reset
->trst
== 1) {
505 ftdi_set_signal(trst
, '0');
507 LOG_ERROR("Can't assert TRST: nTRST signal is not defined");
508 } else if (trst
&& jtag_get_reset_config() & RESET_HAS_TRST
&&
509 cmd
->cmd
.reset
->trst
== 0) {
510 if (jtag_get_reset_config() & RESET_TRST_OPEN_DRAIN
)
511 ftdi_set_signal(trst
, 'z');
513 ftdi_set_signal(trst
, '1');
516 struct signal
*srst
= find_signal_by_name("nSRST");
517 if (cmd
->cmd
.reset
->srst
== 1) {
519 ftdi_set_signal(srst
, '0');
521 LOG_ERROR("Can't assert SRST: nSRST signal is not defined");
522 } else if (srst
&& jtag_get_reset_config() & RESET_HAS_SRST
&&
523 cmd
->cmd
.reset
->srst
== 0) {
524 if (jtag_get_reset_config() & RESET_SRST_PUSH_PULL
)
525 ftdi_set_signal(srst
, '1');
527 ftdi_set_signal(srst
, 'z');
530 DEBUG_JTAG_IO("trst: %i, srst: %i",
531 cmd
->cmd
.reset
->trst
, cmd
->cmd
.reset
->srst
);
534 static void ftdi_execute_sleep(struct jtag_command
*cmd
)
536 DEBUG_JTAG_IO("sleep %" PRIi32
, cmd
->cmd
.sleep
->us
);
538 mpsse_flush(mpsse_ctx
);
539 jtag_sleep(cmd
->cmd
.sleep
->us
);
540 DEBUG_JTAG_IO("sleep %" PRIi32
" usec while in %s",
542 tap_state_name(tap_get_state()));
545 static void ftdi_execute_stableclocks(struct jtag_command
*cmd
)
547 /* this is only allowed while in a stable state. A check for a stable
548 * state was done in jtag_add_clocks()
550 int num_cycles
= cmd
->cmd
.stableclocks
->num_cycles
;
552 /* 7 bits of either ones or zeros. */
553 uint8_t tms
= tap_get_state() == TAP_RESET
? 0x7f : 0x00;
555 /* TODO: Use mpsse_clock_data with in=out=0 for this, if TMS can be set to
556 * the correct level and remain there during the scan */
557 while (num_cycles
> 0) {
558 /* there are no state transitions in this code, so omit state tracking */
559 unsigned this_len
= num_cycles
> 7 ? 7 : num_cycles
;
560 mpsse_clock_tms_cs_out(mpsse_ctx
, &tms
, 0, this_len
, false, ftdi_jtag_mode
);
561 num_cycles
-= this_len
;
564 DEBUG_JTAG_IO("clocks %i while in %s",
565 cmd
->cmd
.stableclocks
->num_cycles
,
566 tap_state_name(tap_get_state()));
569 static void ftdi_execute_command(struct jtag_command
*cmd
)
573 ftdi_execute_reset(cmd
);
576 ftdi_execute_runtest(cmd
);
579 ftdi_execute_statemove(cmd
);
582 ftdi_execute_pathmove(cmd
);
585 ftdi_execute_scan(cmd
);
588 ftdi_execute_sleep(cmd
);
590 case JTAG_STABLECLOCKS
:
591 ftdi_execute_stableclocks(cmd
);
594 ftdi_execute_tms(cmd
);
597 LOG_ERROR("BUG: unknown JTAG command type encountered: %d", cmd
->type
);
602 static int ftdi_execute_queue(void)
604 /* blink, if the current layout has that feature */
605 struct signal
*led
= find_signal_by_name("LED");
607 ftdi_set_signal(led
, '1');
609 for (struct jtag_command
*cmd
= jtag_command_queue
; cmd
; cmd
= cmd
->next
) {
610 /* fill the write buffer with the desired command */
611 ftdi_execute_command(cmd
);
615 ftdi_set_signal(led
, '0');
617 int retval
= mpsse_flush(mpsse_ctx
);
618 if (retval
!= ERROR_OK
)
619 LOG_ERROR("error while flushing MPSSE queue: %d", retval
);
624 static int ftdi_initialize(void)
626 if (tap_get_tms_path_len(TAP_IRPAUSE
, TAP_IRPAUSE
) == 7)
627 LOG_DEBUG("ftdi interface using 7 step jtag state transitions");
629 LOG_DEBUG("ftdi interface using shortest path jtag state transitions");
631 for (int i
= 0; ftdi_vid
[i
] || ftdi_pid
[i
]; i
++) {
632 mpsse_ctx
= mpsse_open(&ftdi_vid
[i
], &ftdi_pid
[i
], ftdi_device_desc
,
633 ftdi_serial
, ftdi_location
, ftdi_channel
);
639 return ERROR_JTAG_INIT_FAILED
;
641 output
= jtag_output_init
;
642 direction
= jtag_direction_init
;
645 struct signal
*sig
= find_signal_by_name("SWD_EN");
647 LOG_ERROR("SWD mode is active but SWD_EN signal is not defined");
648 return ERROR_JTAG_INIT_FAILED
;
650 /* A dummy SWD_EN would have zero mask */
652 ftdi_set_signal(sig
, '1');
655 mpsse_set_data_bits_low_byte(mpsse_ctx
, output
& 0xff, direction
& 0xff);
656 mpsse_set_data_bits_high_byte(mpsse_ctx
, output
>> 8, direction
>> 8);
658 mpsse_loopback_config(mpsse_ctx
, false);
660 freq
= mpsse_set_frequency(mpsse_ctx
, jtag_get_speed_khz() * 1000);
662 return mpsse_flush(mpsse_ctx
);
665 static int ftdi_quit(void)
667 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 #ifdef HAVE_LIBUSB_GET_PORT_NUMBERS
701 COMMAND_HANDLER(ftdi_handle_location_command
)
706 ftdi_location
= strdup(CMD_ARGV
[0]);
708 return ERROR_COMMAND_SYNTAX_ERROR
;
715 COMMAND_HANDLER(ftdi_handle_channel_command
)
718 COMMAND_PARSE_NUMBER(u8
, CMD_ARGV
[0], ftdi_channel
);
720 return ERROR_COMMAND_SYNTAX_ERROR
;
725 COMMAND_HANDLER(ftdi_handle_layout_init_command
)
728 return ERROR_COMMAND_SYNTAX_ERROR
;
730 COMMAND_PARSE_NUMBER(u16
, CMD_ARGV
[0], jtag_output_init
);
731 COMMAND_PARSE_NUMBER(u16
, CMD_ARGV
[1], jtag_direction_init
);
736 COMMAND_HANDLER(ftdi_handle_layout_signal_command
)
739 return ERROR_COMMAND_SYNTAX_ERROR
;
741 bool invert_data
= false;
742 uint16_t data_mask
= 0;
743 bool invert_oe
= false;
744 uint16_t oe_mask
= 0;
745 for (unsigned i
= 1; i
< CMD_ARGC
; i
+= 2) {
746 if (strcmp("-data", CMD_ARGV
[i
]) == 0) {
748 COMMAND_PARSE_NUMBER(u16
, CMD_ARGV
[i
+ 1], data_mask
);
749 } else if (strcmp("-ndata", CMD_ARGV
[i
]) == 0) {
751 COMMAND_PARSE_NUMBER(u16
, CMD_ARGV
[i
+ 1], data_mask
);
752 } else if (strcmp("-oe", CMD_ARGV
[i
]) == 0) {
754 COMMAND_PARSE_NUMBER(u16
, CMD_ARGV
[i
+ 1], oe_mask
);
755 } else if (strcmp("-noe", CMD_ARGV
[i
]) == 0) {
757 COMMAND_PARSE_NUMBER(u16
, CMD_ARGV
[i
+ 1], oe_mask
);
758 } else if (!strcmp("-alias", CMD_ARGV
[i
]) ||
759 !strcmp("-nalias", CMD_ARGV
[i
])) {
760 if (!strcmp("-nalias", CMD_ARGV
[i
]))
762 struct signal
*sig
= find_signal_by_name(CMD_ARGV
[i
+ 1]);
764 LOG_ERROR("signal %s is not defined", CMD_ARGV
[i
+ 1]);
767 data_mask
= sig
->data_mask
;
768 oe_mask
= sig
->oe_mask
;
769 invert_oe
= sig
->invert_oe
;
770 invert_data
^= sig
->invert_data
;
772 LOG_ERROR("unknown option '%s'", CMD_ARGV
[i
]);
773 return ERROR_COMMAND_SYNTAX_ERROR
;
778 sig
= find_signal_by_name(CMD_ARGV
[0]);
780 sig
= create_signal(CMD_ARGV
[0]);
782 LOG_ERROR("failed to create signal %s", CMD_ARGV
[0]);
786 sig
->invert_data
= invert_data
;
787 sig
->data_mask
= data_mask
;
788 sig
->invert_oe
= invert_oe
;
789 sig
->oe_mask
= oe_mask
;
794 COMMAND_HANDLER(ftdi_handle_set_signal_command
)
797 return ERROR_COMMAND_SYNTAX_ERROR
;
800 sig
= find_signal_by_name(CMD_ARGV
[0]);
802 LOG_ERROR("interface configuration doesn't define signal '%s'", CMD_ARGV
[0]);
806 switch (*CMD_ARGV
[1]) {
811 /* single character level specifier only */
812 if (CMD_ARGV
[1][1] == '\0') {
813 ftdi_set_signal(sig
, *CMD_ARGV
[1]);
817 LOG_ERROR("unknown signal level '%s', use 0, 1 or z", CMD_ARGV
[1]);
818 return ERROR_COMMAND_SYNTAX_ERROR
;
821 return mpsse_flush(mpsse_ctx
);
824 COMMAND_HANDLER(ftdi_handle_vid_pid_command
)
826 if (CMD_ARGC
> MAX_USB_IDS
* 2) {
827 LOG_WARNING("ignoring extra IDs in ftdi_vid_pid "
828 "(maximum is %d pairs)", MAX_USB_IDS
);
829 CMD_ARGC
= MAX_USB_IDS
* 2;
831 if (CMD_ARGC
< 2 || (CMD_ARGC
& 1)) {
832 LOG_WARNING("incomplete ftdi_vid_pid configuration directive");
834 return ERROR_COMMAND_SYNTAX_ERROR
;
835 /* remove the incomplete trailing id */
840 for (i
= 0; i
< CMD_ARGC
; i
+= 2) {
841 COMMAND_PARSE_NUMBER(u16
, CMD_ARGV
[i
], ftdi_vid
[i
>> 1]);
842 COMMAND_PARSE_NUMBER(u16
, CMD_ARGV
[i
+ 1], ftdi_pid
[i
>> 1]);
846 * Explicitly terminate, in case there are multiples instances of
849 ftdi_vid
[i
>> 1] = ftdi_pid
[i
>> 1] = 0;
854 COMMAND_HANDLER(ftdi_handle_tdo_sample_edge_command
)
857 static const Jim_Nvp nvp_ftdi_jtag_modes
[] = {
858 { .name
= "rising", .value
= JTAG_MODE
},
859 { .name
= "falling", .value
= JTAG_MODE_ALT
},
860 { .name
= NULL
, .value
= -1 },
864 n
= Jim_Nvp_name2value_simple(nvp_ftdi_jtag_modes
, CMD_ARGV
[0]);
866 return ERROR_COMMAND_SYNTAX_ERROR
;
867 ftdi_jtag_mode
= n
->value
;
871 n
= Jim_Nvp_value2name_simple(nvp_ftdi_jtag_modes
, ftdi_jtag_mode
);
872 command_print(CMD_CTX
, "ftdi samples TDO on %s edge of TCK", n
->name
);
877 static const struct command_registration ftdi_command_handlers
[] = {
879 .name
= "ftdi_device_desc",
880 .handler
= &ftdi_handle_device_desc_command
,
881 .mode
= COMMAND_CONFIG
,
882 .help
= "set the USB device description of the FTDI device",
883 .usage
= "description_string",
886 .name
= "ftdi_serial",
887 .handler
= &ftdi_handle_serial_command
,
888 .mode
= COMMAND_CONFIG
,
889 .help
= "set the serial number of the FTDI device",
890 .usage
= "serial_string",
892 #ifdef HAVE_LIBUSB_GET_PORT_NUMBERS
894 .name
= "ftdi_location",
895 .handler
= &ftdi_handle_location_command
,
896 .mode
= COMMAND_CONFIG
,
897 .help
= "set the USB bus location of the FTDI device",
898 .usage
= "<bus>:port[,port]...",
902 .name
= "ftdi_channel",
903 .handler
= &ftdi_handle_channel_command
,
904 .mode
= COMMAND_CONFIG
,
905 .help
= "set the channel of the FTDI device that is used as JTAG",
909 .name
= "ftdi_layout_init",
910 .handler
= &ftdi_handle_layout_init_command
,
911 .mode
= COMMAND_CONFIG
,
912 .help
= "initialize the FTDI GPIO signals used "
913 "to control output-enables and reset signals",
914 .usage
= "data direction",
917 .name
= "ftdi_layout_signal",
918 .handler
= &ftdi_handle_layout_signal_command
,
920 .help
= "define a signal controlled by one or more FTDI GPIO as data "
921 "and/or output enable",
922 .usage
= "name [-data mask|-ndata mask] [-oe mask|-noe mask] [-alias|-nalias name]",
925 .name
= "ftdi_set_signal",
926 .handler
= &ftdi_handle_set_signal_command
,
927 .mode
= COMMAND_EXEC
,
928 .help
= "control a layout-specific signal",
929 .usage
= "name (1|0|z)",
932 .name
= "ftdi_vid_pid",
933 .handler
= &ftdi_handle_vid_pid_command
,
934 .mode
= COMMAND_CONFIG
,
935 .help
= "the vendor ID and product ID of the FTDI device",
936 .usage
= "(vid pid)* ",
939 .name
= "ftdi_tdo_sample_edge",
940 .handler
= &ftdi_handle_tdo_sample_edge_command
,
942 .help
= "set which TCK clock edge is used for sampling TDO "
943 "- default is rising-edge (Setting to falling-edge may "
944 "allow signalling speed increase)",
945 .usage
= "(rising|falling)",
947 COMMAND_REGISTRATION_DONE
950 static int create_default_signal(const char *name
, uint16_t data_mask
)
952 struct signal
*sig
= create_signal(name
);
954 LOG_ERROR("failed to create signal %s", name
);
957 sig
->invert_data
= false;
958 sig
->data_mask
= data_mask
;
959 sig
->invert_oe
= false;
965 static int create_signals(void)
967 if (create_default_signal("TCK", 0x01) != ERROR_OK
)
969 if (create_default_signal("TDI", 0x02) != ERROR_OK
)
971 if (create_default_signal("TDO", 0x04) != ERROR_OK
)
973 if (create_default_signal("TMS", 0x08) != ERROR_OK
)
978 static int ftdi_swd_init(void)
980 LOG_INFO("FTDI SWD mode enabled");
983 if (create_signals() != ERROR_OK
)
986 swd_cmd_queue_alloced
= 10;
987 swd_cmd_queue
= malloc(swd_cmd_queue_alloced
* sizeof(*swd_cmd_queue
));
989 return swd_cmd_queue
!= NULL
? ERROR_OK
: ERROR_FAIL
;
992 static void ftdi_swd_swdio_en(bool enable
)
994 struct signal
*oe
= find_signal_by_name("SWDIO_OE");
996 ftdi_set_signal(oe
, enable
? '1' : '0');
1000 * Flush the MPSSE queue and process the SWD transaction queue
1004 static int ftdi_swd_run_queue(void)
1006 LOG_DEBUG("Executing %zu queued transactions", swd_cmd_queue_length
);
1008 struct signal
*led
= find_signal_by_name("LED");
1010 if (queued_retval
!= ERROR_OK
) {
1011 LOG_DEBUG("Skipping due to previous errors: %d", queued_retval
);
1015 /* A transaction must be followed by another transaction or at least 8 idle cycles to
1016 * ensure that data is clocked through the AP. */
1017 mpsse_clock_data_out(mpsse_ctx
, NULL
, 0, 8, SWD_MODE
);
1019 /* Terminate the "blink", if the current layout has that feature */
1021 ftdi_set_signal(led
, '0');
1023 queued_retval
= mpsse_flush(mpsse_ctx
);
1024 if (queued_retval
!= ERROR_OK
) {
1025 LOG_ERROR("MPSSE failed");
1029 for (size_t i
= 0; i
< swd_cmd_queue_length
; i
++) {
1030 int ack
= buf_get_u32(swd_cmd_queue
[i
].trn_ack_data_parity_trn
, 1, 3);
1032 LOG_DEBUG("%s %s %s reg %X = %08"PRIx32
,
1033 ack
== SWD_ACK_OK
? "OK" : ack
== SWD_ACK_WAIT
? "WAIT" : ack
== SWD_ACK_FAULT
? "FAULT" : "JUNK",
1034 swd_cmd_queue
[i
].cmd
& SWD_CMD_APnDP
? "AP" : "DP",
1035 swd_cmd_queue
[i
].cmd
& SWD_CMD_RnW
? "read" : "write",
1036 (swd_cmd_queue
[i
].cmd
& SWD_CMD_A32
) >> 1,
1037 buf_get_u32(swd_cmd_queue
[i
].trn_ack_data_parity_trn
,
1038 1 + 3 + (swd_cmd_queue
[i
].cmd
& SWD_CMD_RnW
? 0 : 1), 32));
1040 if (ack
!= SWD_ACK_OK
) {
1041 queued_retval
= ack
== SWD_ACK_WAIT
? ERROR_WAIT
: ERROR_FAIL
;
1044 } else if (swd_cmd_queue
[i
].cmd
& SWD_CMD_RnW
) {
1045 uint32_t data
= buf_get_u32(swd_cmd_queue
[i
].trn_ack_data_parity_trn
, 1 + 3, 32);
1046 int parity
= buf_get_u32(swd_cmd_queue
[i
].trn_ack_data_parity_trn
, 1 + 3 + 32, 1);
1048 if (parity
!= parity_u32(data
)) {
1049 LOG_ERROR("SWD Read data parity mismatch");
1050 queued_retval
= ERROR_FAIL
;
1054 if (swd_cmd_queue
[i
].dst
!= NULL
)
1055 *swd_cmd_queue
[i
].dst
= data
;
1060 swd_cmd_queue_length
= 0;
1061 retval
= queued_retval
;
1062 queued_retval
= ERROR_OK
;
1064 /* Queue a new "blink" */
1065 if (led
&& retval
== ERROR_OK
)
1066 ftdi_set_signal(led
, '1');
1071 static void ftdi_swd_queue_cmd(uint8_t cmd
, uint32_t *dst
, uint32_t data
, uint32_t ap_delay_clk
)
1073 if (swd_cmd_queue_length
>= swd_cmd_queue_alloced
) {
1074 /* Not enough room in the queue. Run the queue and increase its size for next time.
1075 * Note that it's not possible to avoid running the queue here, because mpsse contains
1076 * pointers into the queue which may be invalid after the realloc. */
1077 queued_retval
= ftdi_swd_run_queue();
1078 struct swd_cmd_queue_entry
*q
= realloc(swd_cmd_queue
, swd_cmd_queue_alloced
* 2 * sizeof(*swd_cmd_queue
));
1081 swd_cmd_queue_alloced
*= 2;
1082 LOG_DEBUG("Increased SWD command queue to %zu elements", swd_cmd_queue_alloced
);
1086 if (queued_retval
!= ERROR_OK
)
1089 size_t i
= swd_cmd_queue_length
++;
1090 swd_cmd_queue
[i
].cmd
= cmd
| SWD_CMD_START
| SWD_CMD_PARK
;
1092 mpsse_clock_data_out(mpsse_ctx
, &swd_cmd_queue
[i
].cmd
, 0, 8, SWD_MODE
);
1094 if (swd_cmd_queue
[i
].cmd
& SWD_CMD_RnW
) {
1095 /* Queue a read transaction */
1096 swd_cmd_queue
[i
].dst
= dst
;
1098 ftdi_swd_swdio_en(false);
1099 mpsse_clock_data_in(mpsse_ctx
, swd_cmd_queue
[i
].trn_ack_data_parity_trn
,
1100 0, 1 + 3 + 32 + 1 + 1, SWD_MODE
);
1101 ftdi_swd_swdio_en(true);
1103 /* Queue a write transaction */
1104 ftdi_swd_swdio_en(false);
1106 mpsse_clock_data_in(mpsse_ctx
, swd_cmd_queue
[i
].trn_ack_data_parity_trn
,
1107 0, 1 + 3 + 1, SWD_MODE
);
1109 ftdi_swd_swdio_en(true);
1111 buf_set_u32(swd_cmd_queue
[i
].trn_ack_data_parity_trn
, 1 + 3 + 1, 32, data
);
1112 buf_set_u32(swd_cmd_queue
[i
].trn_ack_data_parity_trn
, 1 + 3 + 1 + 32, 1, parity_u32(data
));
1114 mpsse_clock_data_out(mpsse_ctx
, swd_cmd_queue
[i
].trn_ack_data_parity_trn
,
1115 1 + 3 + 1, 32 + 1, SWD_MODE
);
1118 /* Insert idle cycles after AP accesses to avoid WAIT */
1119 if (cmd
& SWD_CMD_APnDP
)
1120 mpsse_clock_data_out(mpsse_ctx
, NULL
, 0, ap_delay_clk
, SWD_MODE
);
1124 static void ftdi_swd_read_reg(uint8_t cmd
, uint32_t *value
, uint32_t ap_delay_clk
)
1126 assert(cmd
& SWD_CMD_RnW
);
1127 ftdi_swd_queue_cmd(cmd
, value
, 0, ap_delay_clk
);
1130 static void ftdi_swd_write_reg(uint8_t cmd
, uint32_t value
, uint32_t ap_delay_clk
)
1132 assert(!(cmd
& SWD_CMD_RnW
));
1133 ftdi_swd_queue_cmd(cmd
, NULL
, value
, ap_delay_clk
);
1136 static int_least32_t ftdi_swd_frequency(int_least32_t hz
)
1139 freq
= mpsse_set_frequency(mpsse_ctx
, hz
);
1144 static int ftdi_swd_switch_seq(enum swd_special_seq seq
)
1148 LOG_DEBUG("SWD line reset");
1149 mpsse_clock_data_out(mpsse_ctx
, swd_seq_line_reset
, 0, swd_seq_line_reset_len
, SWD_MODE
);
1152 LOG_DEBUG("JTAG-to-SWD");
1153 mpsse_clock_data_out(mpsse_ctx
, swd_seq_jtag_to_swd
, 0, swd_seq_jtag_to_swd_len
, SWD_MODE
);
1156 LOG_DEBUG("SWD-to-JTAG");
1157 mpsse_clock_data_out(mpsse_ctx
, swd_seq_swd_to_jtag
, 0, swd_seq_swd_to_jtag_len
, SWD_MODE
);
1160 LOG_ERROR("Sequence %d not supported", seq
);
1167 static const struct swd_driver ftdi_swd
= {
1168 .init
= ftdi_swd_init
,
1169 .frequency
= ftdi_swd_frequency
,
1170 .switch_seq
= ftdi_swd_switch_seq
,
1171 .read_reg
= ftdi_swd_read_reg
,
1172 .write_reg
= ftdi_swd_write_reg
,
1173 .run
= ftdi_swd_run_queue
,
1176 static const char * const ftdi_transports
[] = { "jtag", "swd", NULL
};
1178 struct jtag_interface ftdi_interface
= {
1180 .supported
= DEBUG_CAP_TMS_SEQ
,
1181 .commands
= ftdi_command_handlers
,
1182 .transports
= ftdi_transports
,
1185 .init
= ftdi_initialize
,
1187 .speed
= ftdi_speed
,
1188 .speed_div
= ftdi_speed_div
,
1190 .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)