1 /**************************************************************************
2 * Copyright (C) 2012 by Andreas Fritiofson *
3 * andreas.fritiofson@gmail.com *
5 * This program is free software; you can redistribute it and/or modify *
6 * it under the terms of the GNU General Public License as published by *
7 * the Free Software Foundation; either version 2 of the License, or *
8 * (at your option) any later version. *
10 * This program is distributed in the hope that it will be useful, *
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
13 * GNU General Public License for more details. *
15 * You should have received a copy of the GNU General Public License *
16 * along with this program; if not, write to the *
17 * Free Software Foundation, Inc., *
18 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. *
19 ***************************************************************************/
23 * JTAG adapters based on the FT2232 full and high speed USB parts are
24 * popular low cost JTAG debug solutions. Many FT2232 based JTAG adapters
25 * are discrete, but development boards may integrate them as alternatives
26 * to more capable (and expensive) third party JTAG pods.
28 * JTAG uses only one of the two communications channels ("MPSSE engines")
29 * on these devices. Adapters based on FT4232 parts have four ports/channels
30 * (A/B/C/D), instead of just two (A/B).
32 * Especially on development boards integrating one of these chips (as
33 * opposed to discrete pods/dongles), the additional channels can be used
34 * for a variety of purposes, but OpenOCD only uses one channel at a time.
36 * - As a USB-to-serial adapter for the target's console UART ...
37 * which may be able to support ROM boot loaders that load initial
38 * firmware images to flash (or SRAM).
40 * - On systems which support ARM's SWD in addition to JTAG, or instead
41 * of it, that second port can be used for reading SWV/SWO trace data.
43 * - Additional JTAG links, e.g. to a CPLD or * FPGA.
45 * FT2232 based JTAG adapters are "dumb" not "smart", because most JTAG
46 * request/response interactions involve round trips over the USB link.
47 * A "smart" JTAG adapter has intelligence close to the scan chain, so it
48 * can for example poll quickly for a status change (usually taking on the
49 * order of microseconds not milliseconds) before beginning a queued
50 * transaction which require the previous one to have completed.
52 * There are dozens of adapters of this type, differing in details which
53 * this driver needs to understand. Those "layout" details are required
54 * as part of FT2232 driver configuration.
56 * This code uses information contained in the MPSSE specification which was
58 * http://www.ftdichip.com/Documents/AppNotes/AN2232C-01_MPSSE_Cmnd.pdf
59 * Hereafter this is called the "MPSSE Spec".
61 * The datasheet for the ftdichip.com's FT2232D part is here:
62 * http://www.ftdichip.com/Documents/DataSheets/DS_FT2232D.pdf
64 * Also note the issue with code 0x4b (clock data to TMS) noted in
65 * http://developer.intra2net.com/mailarchive/html/libftdi/2009/msg00292.html
66 * which can affect longer JTAG state paths.
73 /* project specific includes */
74 #include <jtag/interface.h>
76 #include <transport/transport.h>
77 #include <helper/time_support.h>
85 /* FTDI access library includes */
88 #define JTAG_MODE (LSB_FIRST | POS_EDGE_IN | NEG_EDGE_OUT)
89 #define JTAG_MODE_ALT (LSB_FIRST | NEG_EDGE_IN | NEG_EDGE_OUT)
90 #define SWD_MODE (LSB_FIRST | POS_EDGE_IN | NEG_EDGE_OUT)
92 static char *ftdi_device_desc
;
93 static char *ftdi_serial
;
94 static char *ftdi_location
;
95 static uint8_t ftdi_channel
;
96 static uint8_t ftdi_jtag_mode
= JTAG_MODE
;
100 #define MAX_USB_IDS 8
101 /* vid = pid = 0 marks the end of the list */
102 static uint16_t ftdi_vid
[MAX_USB_IDS
+ 1] = { 0 };
103 static uint16_t ftdi_pid
[MAX_USB_IDS
+ 1] = { 0 };
105 static struct mpsse_ctx
*mpsse_ctx
;
116 static struct signal
*signals
;
118 /* FIXME: Where to store per-instance data? We need an SWD context. */
119 static struct swd_cmd_queue_entry
{
122 uint8_t trn_ack_data_parity_trn
[DIV_ROUND_UP(4 + 3 + 32 + 1 + 4, 8)];
124 static size_t swd_cmd_queue_length
;
125 static size_t swd_cmd_queue_alloced
;
126 static int queued_retval
;
129 static uint16_t output
;
130 static uint16_t direction
;
131 static uint16_t jtag_output_init
;
132 static uint16_t jtag_direction_init
;
134 static int ftdi_swd_switch_seq(enum swd_special_seq seq
);
136 static struct signal
*find_signal_by_name(const char *name
)
138 for (struct signal
*sig
= signals
; sig
; sig
= sig
->next
) {
139 if (strcmp(name
, sig
->name
) == 0)
145 static struct signal
*create_signal(const char *name
)
147 struct signal
**psig
= &signals
;
149 psig
= &(*psig
)->next
;
151 *psig
= calloc(1, sizeof(**psig
));
155 (*psig
)->name
= strdup(name
);
156 if ((*psig
)->name
== NULL
) {
163 static int ftdi_set_signal(const struct signal
*s
, char value
)
168 if (s
->data_mask
== 0 && s
->oe_mask
== 0) {
169 LOG_ERROR("interface doesn't provide signal '%s'", s
->name
);
174 data
= s
->invert_data
;
178 if (s
->data_mask
== 0) {
179 LOG_ERROR("interface can't drive '%s' high", s
->name
);
182 data
= !s
->invert_data
;
187 if (s
->oe_mask
== 0) {
188 LOG_ERROR("interface can't tri-state '%s'", s
->name
);
191 data
= s
->invert_data
;
195 assert(0 && "invalid signal level specifier");
199 uint16_t old_output
= output
;
200 uint16_t old_direction
= direction
;
202 output
= data
? output
| s
->data_mask
: output
& ~s
->data_mask
;
203 if (s
->oe_mask
== s
->data_mask
)
204 direction
= oe
? direction
| s
->oe_mask
: direction
& ~s
->oe_mask
;
206 output
= oe
? output
| s
->oe_mask
: output
& ~s
->oe_mask
;
208 if ((output
& 0xff) != (old_output
& 0xff) || (direction
& 0xff) != (old_direction
& 0xff))
209 mpsse_set_data_bits_low_byte(mpsse_ctx
, output
& 0xff, direction
& 0xff);
210 if ((output
>> 8 != old_output
>> 8) || (direction
>> 8 != old_direction
>> 8))
211 mpsse_set_data_bits_high_byte(mpsse_ctx
, output
>> 8, direction
>> 8);
218 * Function move_to_state
219 * moves the TAP controller from the current state to a
220 * \a goal_state through a path given by tap_get_tms_path(). State transition
221 * logging is performed by delegation to clock_tms().
223 * @param goal_state is the destination state for the move.
225 static void move_to_state(tap_state_t goal_state
)
227 tap_state_t start_state
= tap_get_state();
229 /* goal_state is 1/2 of a tuple/pair of states which allow convenient
230 lookup of the required TMS pattern to move to this state from the
234 /* do the 2 lookups */
235 uint8_t tms_bits
= tap_get_tms_path(start_state
, goal_state
);
236 int tms_count
= tap_get_tms_path_len(start_state
, goal_state
);
237 assert(tms_count
<= 8);
239 DEBUG_JTAG_IO("start=%s goal=%s", tap_state_name(start_state
), tap_state_name(goal_state
));
241 /* Track state transitions step by step */
242 for (int i
= 0; i
< tms_count
; i
++)
243 tap_set_state(tap_state_transition(tap_get_state(), (tms_bits
>> i
) & 1));
245 mpsse_clock_tms_cs_out(mpsse_ctx
,
253 static int ftdi_speed(int speed
)
256 retval
= mpsse_set_frequency(mpsse_ctx
, speed
);
259 LOG_ERROR("couldn't set FTDI TCK speed");
263 if (!swd_mode
&& speed
>= 10000000 && ftdi_jtag_mode
!= JTAG_MODE_ALT
)
264 LOG_INFO("ftdi: if you experience problems at higher adapter clocks, try "
265 "the command \"ftdi_tdo_sample_edge falling\"");
269 static int ftdi_speed_div(int speed
, int *khz
)
275 static int ftdi_khz(int khz
, int *jtag_speed
)
277 if (khz
== 0 && !mpsse_is_high_speed(mpsse_ctx
)) {
278 LOG_DEBUG("RCLK not supported");
282 *jtag_speed
= khz
* 1000;
286 static void ftdi_end_state(tap_state_t state
)
288 if (tap_is_state_stable(state
))
289 tap_set_end_state(state
);
291 LOG_ERROR("BUG: %s is not a stable end state", tap_state_name(state
));
296 static void ftdi_execute_runtest(struct jtag_command
*cmd
)
301 DEBUG_JTAG_IO("runtest %i cycles, end in %s",
302 cmd
->cmd
.runtest
->num_cycles
,
303 tap_state_name(cmd
->cmd
.runtest
->end_state
));
305 if (tap_get_state() != TAP_IDLE
)
306 move_to_state(TAP_IDLE
);
308 /* TODO: Reuse ftdi_execute_stableclocks */
309 i
= cmd
->cmd
.runtest
->num_cycles
;
311 /* there are no state transitions in this code, so omit state tracking */
312 unsigned this_len
= i
> 7 ? 7 : i
;
313 mpsse_clock_tms_cs_out(mpsse_ctx
, &zero
, 0, this_len
, false, ftdi_jtag_mode
);
317 ftdi_end_state(cmd
->cmd
.runtest
->end_state
);
319 if (tap_get_state() != tap_get_end_state())
320 move_to_state(tap_get_end_state());
322 DEBUG_JTAG_IO("runtest: %i, end in %s",
323 cmd
->cmd
.runtest
->num_cycles
,
324 tap_state_name(tap_get_end_state()));
327 static void ftdi_execute_statemove(struct jtag_command
*cmd
)
329 DEBUG_JTAG_IO("statemove end in %s",
330 tap_state_name(cmd
->cmd
.statemove
->end_state
));
332 ftdi_end_state(cmd
->cmd
.statemove
->end_state
);
334 /* shortest-path move to desired end state */
335 if (tap_get_state() != tap_get_end_state() || tap_get_end_state() == TAP_RESET
)
336 move_to_state(tap_get_end_state());
340 * Clock a bunch of TMS (or SWDIO) transitions, to change the JTAG
341 * (or SWD) state machine. REVISIT: Not the best method, perhaps.
343 static void ftdi_execute_tms(struct jtag_command
*cmd
)
345 DEBUG_JTAG_IO("TMS: %d bits", cmd
->cmd
.tms
->num_bits
);
347 /* TODO: Missing tap state tracking, also missing from ft2232.c! */
348 mpsse_clock_tms_cs_out(mpsse_ctx
,
351 cmd
->cmd
.tms
->num_bits
,
356 static void ftdi_execute_pathmove(struct jtag_command
*cmd
)
358 tap_state_t
*path
= cmd
->cmd
.pathmove
->path
;
359 int num_states
= cmd
->cmd
.pathmove
->num_states
;
361 DEBUG_JTAG_IO("pathmove: %i states, current: %s end: %s", num_states
,
362 tap_state_name(tap_get_state()),
363 tap_state_name(path
[num_states
-1]));
366 unsigned bit_count
= 0;
367 uint8_t tms_byte
= 0;
371 /* this loop verifies that the path is legal and logs each state in the path */
372 while (num_states
--) {
374 /* either TMS=0 or TMS=1 must work ... */
375 if (tap_state_transition(tap_get_state(), false)
376 == path
[state_count
])
377 buf_set_u32(&tms_byte
, bit_count
++, 1, 0x0);
378 else if (tap_state_transition(tap_get_state(), true)
379 == path
[state_count
]) {
380 buf_set_u32(&tms_byte
, bit_count
++, 1, 0x1);
382 /* ... or else the caller goofed BADLY */
384 LOG_ERROR("BUG: %s -> %s isn't a valid "
385 "TAP state transition",
386 tap_state_name(tap_get_state()),
387 tap_state_name(path
[state_count
]));
391 tap_set_state(path
[state_count
]);
394 if (bit_count
== 7 || num_states
== 0) {
395 mpsse_clock_tms_cs_out(mpsse_ctx
,
404 tap_set_end_state(tap_get_state());
407 static void ftdi_execute_scan(struct jtag_command
*cmd
)
409 DEBUG_JTAG_IO("%s type:%d", cmd
->cmd
.scan
->ir_scan
? "IRSCAN" : "DRSCAN",
410 jtag_scan_type(cmd
->cmd
.scan
));
412 /* Make sure there are no trailing fields with num_bits == 0, or the logic below will fail. */
413 while (cmd
->cmd
.scan
->num_fields
> 0
414 && cmd
->cmd
.scan
->fields
[cmd
->cmd
.scan
->num_fields
- 1].num_bits
== 0) {
415 cmd
->cmd
.scan
->num_fields
--;
416 LOG_DEBUG("discarding trailing empty field");
419 if (cmd
->cmd
.scan
->num_fields
== 0) {
420 LOG_DEBUG("empty scan, doing nothing");
424 if (cmd
->cmd
.scan
->ir_scan
) {
425 if (tap_get_state() != TAP_IRSHIFT
)
426 move_to_state(TAP_IRSHIFT
);
428 if (tap_get_state() != TAP_DRSHIFT
)
429 move_to_state(TAP_DRSHIFT
);
432 ftdi_end_state(cmd
->cmd
.scan
->end_state
);
434 struct scan_field
*field
= cmd
->cmd
.scan
->fields
;
435 unsigned scan_size
= 0;
437 for (int i
= 0; i
< cmd
->cmd
.scan
->num_fields
; i
++, field
++) {
438 scan_size
+= field
->num_bits
;
439 DEBUG_JTAG_IO("%s%s field %d/%d %d bits",
440 field
->in_value
? "in" : "",
441 field
->out_value
? "out" : "",
443 cmd
->cmd
.scan
->num_fields
,
446 if (i
== cmd
->cmd
.scan
->num_fields
- 1 && tap_get_state() != tap_get_end_state()) {
447 /* Last field, and we're leaving IRSHIFT/DRSHIFT. Clock last bit during tap
448 * movement. This last field can't have length zero, it was checked above. */
449 mpsse_clock_data(mpsse_ctx
,
456 uint8_t last_bit
= 0;
457 if (field
->out_value
)
458 bit_copy(&last_bit
, 0, field
->out_value
, field
->num_bits
- 1, 1);
459 uint8_t tms_bits
= 0x01;
460 mpsse_clock_tms_cs(mpsse_ctx
,
468 tap_set_state(tap_state_transition(tap_get_state(), 1));
469 mpsse_clock_tms_cs_out(mpsse_ctx
,
475 tap_set_state(tap_state_transition(tap_get_state(), 0));
477 mpsse_clock_data(mpsse_ctx
,
486 if (tap_get_state() != tap_get_end_state())
487 move_to_state(tap_get_end_state());
489 DEBUG_JTAG_IO("%s scan, %i bits, end in %s",
490 (cmd
->cmd
.scan
->ir_scan
) ? "IR" : "DR", scan_size
,
491 tap_state_name(tap_get_end_state()));
494 static void ftdi_execute_reset(struct jtag_command
*cmd
)
496 DEBUG_JTAG_IO("reset trst: %i srst %i",
497 cmd
->cmd
.reset
->trst
, cmd
->cmd
.reset
->srst
);
499 if (cmd
->cmd
.reset
->trst
== 1
500 || (cmd
->cmd
.reset
->srst
501 && (jtag_get_reset_config() & RESET_SRST_PULLS_TRST
)))
502 tap_set_state(TAP_RESET
);
504 struct signal
*trst
= find_signal_by_name("nTRST");
505 if (cmd
->cmd
.reset
->trst
== 1) {
507 ftdi_set_signal(trst
, '0');
509 LOG_ERROR("Can't assert TRST: nTRST signal is not defined");
510 } else if (trst
&& jtag_get_reset_config() & RESET_HAS_TRST
&&
511 cmd
->cmd
.reset
->trst
== 0) {
512 if (jtag_get_reset_config() & RESET_TRST_OPEN_DRAIN
)
513 ftdi_set_signal(trst
, 'z');
515 ftdi_set_signal(trst
, '1');
518 struct signal
*srst
= find_signal_by_name("nSRST");
519 if (cmd
->cmd
.reset
->srst
== 1) {
521 ftdi_set_signal(srst
, '0');
523 LOG_ERROR("Can't assert SRST: nSRST signal is not defined");
524 } else if (srst
&& jtag_get_reset_config() & RESET_HAS_SRST
&&
525 cmd
->cmd
.reset
->srst
== 0) {
526 if (jtag_get_reset_config() & RESET_SRST_PUSH_PULL
)
527 ftdi_set_signal(srst
, '1');
529 ftdi_set_signal(srst
, 'z');
532 DEBUG_JTAG_IO("trst: %i, srst: %i",
533 cmd
->cmd
.reset
->trst
, cmd
->cmd
.reset
->srst
);
536 static void ftdi_execute_sleep(struct jtag_command
*cmd
)
538 DEBUG_JTAG_IO("sleep %" PRIi32
, cmd
->cmd
.sleep
->us
);
540 mpsse_flush(mpsse_ctx
);
541 jtag_sleep(cmd
->cmd
.sleep
->us
);
542 DEBUG_JTAG_IO("sleep %" PRIi32
" usec while in %s",
544 tap_state_name(tap_get_state()));
547 static void ftdi_execute_stableclocks(struct jtag_command
*cmd
)
549 /* this is only allowed while in a stable state. A check for a stable
550 * state was done in jtag_add_clocks()
552 int num_cycles
= cmd
->cmd
.stableclocks
->num_cycles
;
554 /* 7 bits of either ones or zeros. */
555 uint8_t tms
= tap_get_state() == TAP_RESET
? 0x7f : 0x00;
557 /* TODO: Use mpsse_clock_data with in=out=0 for this, if TMS can be set to
558 * the correct level and remain there during the scan */
559 while (num_cycles
> 0) {
560 /* there are no state transitions in this code, so omit state tracking */
561 unsigned this_len
= num_cycles
> 7 ? 7 : num_cycles
;
562 mpsse_clock_tms_cs_out(mpsse_ctx
, &tms
, 0, this_len
, false, ftdi_jtag_mode
);
563 num_cycles
-= this_len
;
566 DEBUG_JTAG_IO("clocks %i while in %s",
567 cmd
->cmd
.stableclocks
->num_cycles
,
568 tap_state_name(tap_get_state()));
571 static void ftdi_execute_command(struct jtag_command
*cmd
)
575 ftdi_execute_reset(cmd
);
578 ftdi_execute_runtest(cmd
);
581 ftdi_execute_statemove(cmd
);
584 ftdi_execute_pathmove(cmd
);
587 ftdi_execute_scan(cmd
);
590 ftdi_execute_sleep(cmd
);
592 case JTAG_STABLECLOCKS
:
593 ftdi_execute_stableclocks(cmd
);
596 ftdi_execute_tms(cmd
);
599 LOG_ERROR("BUG: unknown JTAG command type encountered: %d", cmd
->type
);
604 static int ftdi_execute_queue(void)
606 /* blink, if the current layout has that feature */
607 struct signal
*led
= find_signal_by_name("LED");
609 ftdi_set_signal(led
, '1');
611 for (struct jtag_command
*cmd
= jtag_command_queue
; cmd
; cmd
= cmd
->next
) {
612 /* fill the write buffer with the desired command */
613 ftdi_execute_command(cmd
);
617 ftdi_set_signal(led
, '0');
619 int retval
= mpsse_flush(mpsse_ctx
);
620 if (retval
!= ERROR_OK
)
621 LOG_ERROR("error while flushing MPSSE queue: %d", retval
);
626 static int ftdi_initialize(void)
628 if (tap_get_tms_path_len(TAP_IRPAUSE
, TAP_IRPAUSE
) == 7)
629 LOG_DEBUG("ftdi interface using 7 step jtag state transitions");
631 LOG_DEBUG("ftdi interface using shortest path jtag state transitions");
633 for (int i
= 0; ftdi_vid
[i
] || ftdi_pid
[i
]; i
++) {
634 mpsse_ctx
= mpsse_open(&ftdi_vid
[i
], &ftdi_pid
[i
], ftdi_device_desc
,
635 ftdi_serial
, ftdi_location
, ftdi_channel
);
641 return ERROR_JTAG_INIT_FAILED
;
643 output
= jtag_output_init
;
644 direction
= jtag_direction_init
;
647 struct signal
*sig
= find_signal_by_name("SWD_EN");
649 LOG_ERROR("SWD mode is active but SWD_EN signal is not defined");
650 return ERROR_JTAG_INIT_FAILED
;
652 /* A dummy SWD_EN would have zero mask */
654 ftdi_set_signal(sig
, '1');
657 mpsse_set_data_bits_low_byte(mpsse_ctx
, output
& 0xff, direction
& 0xff);
658 mpsse_set_data_bits_high_byte(mpsse_ctx
, output
>> 8, direction
>> 8);
660 mpsse_loopback_config(mpsse_ctx
, false);
662 freq
= mpsse_set_frequency(mpsse_ctx
, jtag_get_speed_khz() * 1000);
664 return mpsse_flush(mpsse_ctx
);
667 static int ftdi_quit(void)
669 mpsse_close(mpsse_ctx
);
676 COMMAND_HANDLER(ftdi_handle_device_desc_command
)
679 if (ftdi_device_desc
)
680 free(ftdi_device_desc
);
681 ftdi_device_desc
= strdup(CMD_ARGV
[0]);
683 LOG_ERROR("expected exactly one argument to ftdi_device_desc <description>");
689 COMMAND_HANDLER(ftdi_handle_serial_command
)
694 ftdi_serial
= strdup(CMD_ARGV
[0]);
696 return ERROR_COMMAND_SYNTAX_ERROR
;
702 #ifdef HAVE_LIBUSB_GET_PORT_NUMBERS
703 COMMAND_HANDLER(ftdi_handle_location_command
)
708 ftdi_location
= strdup(CMD_ARGV
[0]);
710 return ERROR_COMMAND_SYNTAX_ERROR
;
717 COMMAND_HANDLER(ftdi_handle_channel_command
)
720 COMMAND_PARSE_NUMBER(u8
, CMD_ARGV
[0], ftdi_channel
);
722 return ERROR_COMMAND_SYNTAX_ERROR
;
727 COMMAND_HANDLER(ftdi_handle_layout_init_command
)
730 return ERROR_COMMAND_SYNTAX_ERROR
;
732 COMMAND_PARSE_NUMBER(u16
, CMD_ARGV
[0], jtag_output_init
);
733 COMMAND_PARSE_NUMBER(u16
, CMD_ARGV
[1], jtag_direction_init
);
738 COMMAND_HANDLER(ftdi_handle_layout_signal_command
)
741 return ERROR_COMMAND_SYNTAX_ERROR
;
743 bool invert_data
= false;
744 uint16_t data_mask
= 0;
745 bool invert_oe
= false;
746 uint16_t oe_mask
= 0;
747 for (unsigned i
= 1; i
< CMD_ARGC
; i
+= 2) {
748 if (strcmp("-data", CMD_ARGV
[i
]) == 0) {
750 COMMAND_PARSE_NUMBER(u16
, CMD_ARGV
[i
+ 1], data_mask
);
751 } else if (strcmp("-ndata", CMD_ARGV
[i
]) == 0) {
753 COMMAND_PARSE_NUMBER(u16
, CMD_ARGV
[i
+ 1], data_mask
);
754 } else if (strcmp("-oe", CMD_ARGV
[i
]) == 0) {
756 COMMAND_PARSE_NUMBER(u16
, CMD_ARGV
[i
+ 1], oe_mask
);
757 } else if (strcmp("-noe", CMD_ARGV
[i
]) == 0) {
759 COMMAND_PARSE_NUMBER(u16
, CMD_ARGV
[i
+ 1], oe_mask
);
760 } else if (!strcmp("-alias", CMD_ARGV
[i
]) ||
761 !strcmp("-nalias", CMD_ARGV
[i
])) {
762 if (!strcmp("-nalias", CMD_ARGV
[i
]))
764 struct signal
*sig
= find_signal_by_name(CMD_ARGV
[i
+ 1]);
766 LOG_ERROR("signal %s is not defined", CMD_ARGV
[i
+ 1]);
769 data_mask
= sig
->data_mask
;
770 oe_mask
= sig
->oe_mask
;
771 invert_oe
= sig
->invert_oe
;
772 invert_data
^= sig
->invert_data
;
774 LOG_ERROR("unknown option '%s'", CMD_ARGV
[i
]);
775 return ERROR_COMMAND_SYNTAX_ERROR
;
780 sig
= find_signal_by_name(CMD_ARGV
[0]);
782 sig
= create_signal(CMD_ARGV
[0]);
784 LOG_ERROR("failed to create signal %s", CMD_ARGV
[0]);
788 sig
->invert_data
= invert_data
;
789 sig
->data_mask
= data_mask
;
790 sig
->invert_oe
= invert_oe
;
791 sig
->oe_mask
= oe_mask
;
796 COMMAND_HANDLER(ftdi_handle_set_signal_command
)
799 return ERROR_COMMAND_SYNTAX_ERROR
;
802 sig
= find_signal_by_name(CMD_ARGV
[0]);
804 LOG_ERROR("interface configuration doesn't define signal '%s'", CMD_ARGV
[0]);
808 switch (*CMD_ARGV
[1]) {
813 /* single character level specifier only */
814 if (CMD_ARGV
[1][1] == '\0') {
815 ftdi_set_signal(sig
, *CMD_ARGV
[1]);
819 LOG_ERROR("unknown signal level '%s', use 0, 1 or z", CMD_ARGV
[1]);
820 return ERROR_COMMAND_SYNTAX_ERROR
;
823 return mpsse_flush(mpsse_ctx
);
826 COMMAND_HANDLER(ftdi_handle_vid_pid_command
)
828 if (CMD_ARGC
> MAX_USB_IDS
* 2) {
829 LOG_WARNING("ignoring extra IDs in ftdi_vid_pid "
830 "(maximum is %d pairs)", MAX_USB_IDS
);
831 CMD_ARGC
= MAX_USB_IDS
* 2;
833 if (CMD_ARGC
< 2 || (CMD_ARGC
& 1)) {
834 LOG_WARNING("incomplete ftdi_vid_pid configuration directive");
836 return ERROR_COMMAND_SYNTAX_ERROR
;
837 /* remove the incomplete trailing id */
842 for (i
= 0; i
< CMD_ARGC
; i
+= 2) {
843 COMMAND_PARSE_NUMBER(u16
, CMD_ARGV
[i
], ftdi_vid
[i
>> 1]);
844 COMMAND_PARSE_NUMBER(u16
, CMD_ARGV
[i
+ 1], ftdi_pid
[i
>> 1]);
848 * Explicitly terminate, in case there are multiples instances of
851 ftdi_vid
[i
>> 1] = ftdi_pid
[i
>> 1] = 0;
856 COMMAND_HANDLER(ftdi_handle_tdo_sample_edge_command
)
859 static const Jim_Nvp nvp_ftdi_jtag_modes
[] = {
860 { .name
= "rising", .value
= JTAG_MODE
},
861 { .name
= "falling", .value
= JTAG_MODE_ALT
},
862 { .name
= NULL
, .value
= -1 },
866 n
= Jim_Nvp_name2value_simple(nvp_ftdi_jtag_modes
, CMD_ARGV
[0]);
868 return ERROR_COMMAND_SYNTAX_ERROR
;
869 ftdi_jtag_mode
= n
->value
;
873 n
= Jim_Nvp_value2name_simple(nvp_ftdi_jtag_modes
, ftdi_jtag_mode
);
874 command_print(CMD_CTX
, "ftdi samples TDO on %s edge of TCK", n
->name
);
879 static const struct command_registration ftdi_command_handlers
[] = {
881 .name
= "ftdi_device_desc",
882 .handler
= &ftdi_handle_device_desc_command
,
883 .mode
= COMMAND_CONFIG
,
884 .help
= "set the USB device description of the FTDI device",
885 .usage
= "description_string",
888 .name
= "ftdi_serial",
889 .handler
= &ftdi_handle_serial_command
,
890 .mode
= COMMAND_CONFIG
,
891 .help
= "set the serial number of the FTDI device",
892 .usage
= "serial_string",
894 #ifdef HAVE_LIBUSB_GET_PORT_NUMBERS
896 .name
= "ftdi_location",
897 .handler
= &ftdi_handle_location_command
,
898 .mode
= COMMAND_CONFIG
,
899 .help
= "set the USB bus location of the FTDI device",
900 .usage
= "<bus>:port[,port]...",
904 .name
= "ftdi_channel",
905 .handler
= &ftdi_handle_channel_command
,
906 .mode
= COMMAND_CONFIG
,
907 .help
= "set the channel of the FTDI device that is used as JTAG",
911 .name
= "ftdi_layout_init",
912 .handler
= &ftdi_handle_layout_init_command
,
913 .mode
= COMMAND_CONFIG
,
914 .help
= "initialize the FTDI GPIO signals used "
915 "to control output-enables and reset signals",
916 .usage
= "data direction",
919 .name
= "ftdi_layout_signal",
920 .handler
= &ftdi_handle_layout_signal_command
,
922 .help
= "define a signal controlled by one or more FTDI GPIO as data "
923 "and/or output enable",
924 .usage
= "name [-data mask|-ndata mask] [-oe mask|-noe mask] [-alias|-nalias name]",
927 .name
= "ftdi_set_signal",
928 .handler
= &ftdi_handle_set_signal_command
,
929 .mode
= COMMAND_EXEC
,
930 .help
= "control a layout-specific signal",
931 .usage
= "name (1|0|z)",
934 .name
= "ftdi_vid_pid",
935 .handler
= &ftdi_handle_vid_pid_command
,
936 .mode
= COMMAND_CONFIG
,
937 .help
= "the vendor ID and product ID of the FTDI device",
938 .usage
= "(vid pid)* ",
941 .name
= "ftdi_tdo_sample_edge",
942 .handler
= &ftdi_handle_tdo_sample_edge_command
,
944 .help
= "set which TCK clock edge is used for sampling TDO "
945 "- default is rising-edge (Setting to falling-edge may "
946 "allow signalling speed increase)",
947 .usage
= "(rising|falling)",
949 COMMAND_REGISTRATION_DONE
952 static int create_default_signal(const char *name
, uint16_t data_mask
)
954 struct signal
*sig
= create_signal(name
);
956 LOG_ERROR("failed to create signal %s", name
);
959 sig
->invert_data
= false;
960 sig
->data_mask
= data_mask
;
961 sig
->invert_oe
= false;
967 static int create_signals(void)
969 if (create_default_signal("TCK", 0x01) != ERROR_OK
)
971 if (create_default_signal("TDI", 0x02) != ERROR_OK
)
973 if (create_default_signal("TDO", 0x04) != ERROR_OK
)
975 if (create_default_signal("TMS", 0x08) != ERROR_OK
)
980 static int ftdi_swd_init(void)
982 LOG_INFO("FTDI SWD mode enabled");
985 if (create_signals() != ERROR_OK
)
988 swd_cmd_queue_alloced
= 10;
989 swd_cmd_queue
= malloc(swd_cmd_queue_alloced
* sizeof(*swd_cmd_queue
));
991 return swd_cmd_queue
!= NULL
? ERROR_OK
: ERROR_FAIL
;
994 static void ftdi_swd_swdio_en(bool enable
)
996 struct signal
*oe
= find_signal_by_name("SWDIO_OE");
998 ftdi_set_signal(oe
, enable
? '1' : '0');
1002 * Flush the MPSSE queue and process the SWD transaction queue
1006 static int ftdi_swd_run_queue(void)
1008 LOG_DEBUG("Executing %zu queued transactions", swd_cmd_queue_length
);
1010 struct signal
*led
= find_signal_by_name("LED");
1012 if (queued_retval
!= ERROR_OK
) {
1013 LOG_DEBUG("Skipping due to previous errors: %d", queued_retval
);
1017 /* A transaction must be followed by another transaction or at least 8 idle cycles to
1018 * ensure that data is clocked through the AP. */
1019 mpsse_clock_data_out(mpsse_ctx
, NULL
, 0, 8, SWD_MODE
);
1021 /* Terminate the "blink", if the current layout has that feature */
1023 ftdi_set_signal(led
, '0');
1025 queued_retval
= mpsse_flush(mpsse_ctx
);
1026 if (queued_retval
!= ERROR_OK
) {
1027 LOG_ERROR("MPSSE failed");
1031 for (size_t i
= 0; i
< swd_cmd_queue_length
; i
++) {
1032 int ack
= buf_get_u32(swd_cmd_queue
[i
].trn_ack_data_parity_trn
, 1, 3);
1034 LOG_DEBUG("%s %s %s reg %X = %08"PRIx32
,
1035 ack
== SWD_ACK_OK
? "OK" : ack
== SWD_ACK_WAIT
? "WAIT" : ack
== SWD_ACK_FAULT
? "FAULT" : "JUNK",
1036 swd_cmd_queue
[i
].cmd
& SWD_CMD_APnDP
? "AP" : "DP",
1037 swd_cmd_queue
[i
].cmd
& SWD_CMD_RnW
? "read" : "write",
1038 (swd_cmd_queue
[i
].cmd
& SWD_CMD_A32
) >> 1,
1039 buf_get_u32(swd_cmd_queue
[i
].trn_ack_data_parity_trn
,
1040 1 + 3 + (swd_cmd_queue
[i
].cmd
& SWD_CMD_RnW
? 0 : 1), 32));
1042 if (ack
!= SWD_ACK_OK
) {
1043 queued_retval
= ack
== SWD_ACK_WAIT
? ERROR_WAIT
: ERROR_FAIL
;
1046 } else if (swd_cmd_queue
[i
].cmd
& SWD_CMD_RnW
) {
1047 uint32_t data
= buf_get_u32(swd_cmd_queue
[i
].trn_ack_data_parity_trn
, 1 + 3, 32);
1048 int parity
= buf_get_u32(swd_cmd_queue
[i
].trn_ack_data_parity_trn
, 1 + 3 + 32, 1);
1050 if (parity
!= parity_u32(data
)) {
1051 LOG_ERROR("SWD Read data parity mismatch");
1052 queued_retval
= ERROR_FAIL
;
1056 if (swd_cmd_queue
[i
].dst
!= NULL
)
1057 *swd_cmd_queue
[i
].dst
= data
;
1062 swd_cmd_queue_length
= 0;
1063 retval
= queued_retval
;
1064 queued_retval
= ERROR_OK
;
1066 /* Queue a new "blink" */
1067 if (led
&& retval
== ERROR_OK
)
1068 ftdi_set_signal(led
, '1');
1073 static void ftdi_swd_queue_cmd(uint8_t cmd
, uint32_t *dst
, uint32_t data
, uint32_t ap_delay_clk
)
1075 if (swd_cmd_queue_length
>= swd_cmd_queue_alloced
) {
1076 /* Not enough room in the queue. Run the queue and increase its size for next time.
1077 * Note that it's not possible to avoid running the queue here, because mpsse contains
1078 * pointers into the queue which may be invalid after the realloc. */
1079 queued_retval
= ftdi_swd_run_queue();
1080 struct swd_cmd_queue_entry
*q
= realloc(swd_cmd_queue
, swd_cmd_queue_alloced
* 2 * sizeof(*swd_cmd_queue
));
1083 swd_cmd_queue_alloced
*= 2;
1084 LOG_DEBUG("Increased SWD command queue to %zu elements", swd_cmd_queue_alloced
);
1088 if (queued_retval
!= ERROR_OK
)
1091 size_t i
= swd_cmd_queue_length
++;
1092 swd_cmd_queue
[i
].cmd
= cmd
| SWD_CMD_START
| SWD_CMD_PARK
;
1094 mpsse_clock_data_out(mpsse_ctx
, &swd_cmd_queue
[i
].cmd
, 0, 8, SWD_MODE
);
1096 if (swd_cmd_queue
[i
].cmd
& SWD_CMD_RnW
) {
1097 /* Queue a read transaction */
1098 swd_cmd_queue
[i
].dst
= dst
;
1100 ftdi_swd_swdio_en(false);
1101 mpsse_clock_data_in(mpsse_ctx
, swd_cmd_queue
[i
].trn_ack_data_parity_trn
,
1102 0, 1 + 3 + 32 + 1 + 1, SWD_MODE
);
1103 ftdi_swd_swdio_en(true);
1105 /* Queue a write transaction */
1106 ftdi_swd_swdio_en(false);
1108 mpsse_clock_data_in(mpsse_ctx
, swd_cmd_queue
[i
].trn_ack_data_parity_trn
,
1109 0, 1 + 3 + 1, SWD_MODE
);
1111 ftdi_swd_swdio_en(true);
1113 buf_set_u32(swd_cmd_queue
[i
].trn_ack_data_parity_trn
, 1 + 3 + 1, 32, data
);
1114 buf_set_u32(swd_cmd_queue
[i
].trn_ack_data_parity_trn
, 1 + 3 + 1 + 32, 1, parity_u32(data
));
1116 mpsse_clock_data_out(mpsse_ctx
, swd_cmd_queue
[i
].trn_ack_data_parity_trn
,
1117 1 + 3 + 1, 32 + 1, SWD_MODE
);
1120 /* Insert idle cycles after AP accesses to avoid WAIT */
1121 if (cmd
& SWD_CMD_APnDP
)
1122 mpsse_clock_data_out(mpsse_ctx
, NULL
, 0, ap_delay_clk
, SWD_MODE
);
1126 static void ftdi_swd_read_reg(uint8_t cmd
, uint32_t *value
, uint32_t ap_delay_clk
)
1128 assert(cmd
& SWD_CMD_RnW
);
1129 ftdi_swd_queue_cmd(cmd
, value
, 0, ap_delay_clk
);
1132 static void ftdi_swd_write_reg(uint8_t cmd
, uint32_t value
, uint32_t ap_delay_clk
)
1134 assert(!(cmd
& SWD_CMD_RnW
));
1135 ftdi_swd_queue_cmd(cmd
, NULL
, value
, ap_delay_clk
);
1138 static int_least32_t ftdi_swd_frequency(int_least32_t hz
)
1141 freq
= mpsse_set_frequency(mpsse_ctx
, hz
);
1146 static int ftdi_swd_switch_seq(enum swd_special_seq seq
)
1150 LOG_DEBUG("SWD line reset");
1151 mpsse_clock_data_out(mpsse_ctx
, swd_seq_line_reset
, 0, swd_seq_line_reset_len
, SWD_MODE
);
1154 LOG_DEBUG("JTAG-to-SWD");
1155 mpsse_clock_data_out(mpsse_ctx
, swd_seq_jtag_to_swd
, 0, swd_seq_jtag_to_swd_len
, SWD_MODE
);
1158 LOG_DEBUG("SWD-to-JTAG");
1159 mpsse_clock_data_out(mpsse_ctx
, swd_seq_swd_to_jtag
, 0, swd_seq_swd_to_jtag_len
, SWD_MODE
);
1162 LOG_ERROR("Sequence %d not supported", seq
);
1169 static const struct swd_driver ftdi_swd
= {
1170 .init
= ftdi_swd_init
,
1171 .frequency
= ftdi_swd_frequency
,
1172 .switch_seq
= ftdi_swd_switch_seq
,
1173 .read_reg
= ftdi_swd_read_reg
,
1174 .write_reg
= ftdi_swd_write_reg
,
1175 .run
= ftdi_swd_run_queue
,
1178 static const char * const ftdi_transports
[] = { "jtag", "swd", NULL
};
1180 struct jtag_interface ftdi_interface
= {
1182 .supported
= DEBUG_CAP_TMS_SEQ
,
1183 .commands
= ftdi_command_handlers
,
1184 .transports
= ftdi_transports
,
1187 .init
= ftdi_initialize
,
1189 .speed
= ftdi_speed
,
1190 .speed_div
= ftdi_speed_div
,
1192 .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)