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 * https://www.ftdichip.com/Support/Documents/AppNotes/AN2232C-01_MPSSE_Cmnd.pdf
57 * Hereafter this is called the "MPSSE Spec".
59 * The datasheet for the ftdichip.com's FT2232H part is here:
60 * https://www.ftdichip.com/Support/Documents/DataSheets/ICs/DS_FT2232H.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/drivers/jtag_usb_common.h>
73 #include <jtag/interface.h>
75 #include <transport/transport.h>
76 #include <helper/time_support.h>
77 #include <helper/log.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 uint8_t ftdi_channel
;
95 static uint8_t ftdi_jtag_mode
= JTAG_MODE
;
100 /* vid = pid = 0 marks the end of the list */
101 static uint16_t ftdi_vid
[MAX_USB_IDS
+ 1] = { 0 };
102 static uint16_t ftdi_pid
[MAX_USB_IDS
+ 1] = { 0 };
104 static struct mpsse_ctx
*mpsse_ctx
;
117 static struct signal
*signals
;
119 /* FIXME: Where to store per-instance data? We need an SWD context. */
120 static struct swd_cmd_queue_entry
{
123 uint8_t trn_ack_data_parity_trn
[DIV_ROUND_UP(4 + 3 + 32 + 1 + 4, 8)];
125 static size_t swd_cmd_queue_length
;
126 static size_t swd_cmd_queue_alloced
;
127 static int queued_retval
;
130 static uint16_t output
;
131 static uint16_t direction
;
132 static uint16_t jtag_output_init
;
133 static uint16_t jtag_direction_init
;
135 static int ftdi_swd_switch_seq(enum swd_special_seq seq
);
137 static struct signal
*find_signal_by_name(const char *name
)
139 for (struct signal
*sig
= signals
; sig
; sig
= sig
->next
) {
140 if (strcmp(name
, sig
->name
) == 0)
146 static struct signal
*create_signal(const char *name
)
148 struct signal
**psig
= &signals
;
150 psig
= &(*psig
)->next
;
152 *psig
= calloc(1, sizeof(**psig
));
156 (*psig
)->name
= strdup(name
);
157 if (!(*psig
)->name
) {
164 static int ftdi_set_signal(const struct signal
*s
, char value
)
169 if (s
->data_mask
== 0 && s
->oe_mask
== 0) {
170 LOG_ERROR("interface doesn't provide signal '%s'", s
->name
);
175 data
= s
->invert_data
;
179 if (s
->data_mask
== 0) {
180 LOG_ERROR("interface can't drive '%s' high", s
->name
);
183 data
= !s
->invert_data
;
188 if (s
->oe_mask
== 0) {
189 LOG_ERROR("interface can't tri-state '%s'", s
->name
);
192 data
= s
->invert_data
;
196 assert(0 && "invalid signal level specifier");
200 uint16_t old_output
= output
;
201 uint16_t old_direction
= direction
;
203 output
= data
? output
| s
->data_mask
: output
& ~s
->data_mask
;
204 if (s
->oe_mask
== s
->data_mask
)
205 direction
= oe
? direction
| s
->oe_mask
: direction
& ~s
->oe_mask
;
207 output
= oe
? output
| s
->oe_mask
: output
& ~s
->oe_mask
;
209 if ((output
& 0xff) != (old_output
& 0xff) || (direction
& 0xff) != (old_direction
& 0xff))
210 mpsse_set_data_bits_low_byte(mpsse_ctx
, output
& 0xff, direction
& 0xff);
211 if ((output
>> 8 != old_output
>> 8) || (direction
>> 8 != old_direction
>> 8))
212 mpsse_set_data_bits_high_byte(mpsse_ctx
, output
>> 8, direction
>> 8);
217 static int ftdi_get_signal(const struct signal
*s
, uint16_t *value_out
)
219 uint8_t data_low
= 0;
220 uint8_t data_high
= 0;
222 if (s
->input_mask
== 0) {
223 LOG_ERROR("interface doesn't provide signal '%s'", s
->name
);
227 if (s
->input_mask
& 0xff)
228 mpsse_read_data_bits_low_byte(mpsse_ctx
, &data_low
);
229 if (s
->input_mask
>> 8)
230 mpsse_read_data_bits_high_byte(mpsse_ctx
, &data_high
);
232 mpsse_flush(mpsse_ctx
);
234 *value_out
= (((uint16_t)data_high
) << 8) | data_low
;
237 *value_out
= ~(*value_out
);
239 *value_out
&= s
->input_mask
;
245 * Function move_to_state
246 * moves the TAP controller from the current state to a
247 * \a goal_state through a path given by tap_get_tms_path(). State transition
248 * logging is performed by delegation to clock_tms().
250 * @param goal_state is the destination state for the move.
252 static void move_to_state(tap_state_t goal_state
)
254 tap_state_t start_state
= tap_get_state();
256 /* goal_state is 1/2 of a tuple/pair of states which allow convenient
257 lookup of the required TMS pattern to move to this state from the
261 /* do the 2 lookups */
262 uint8_t tms_bits
= tap_get_tms_path(start_state
, goal_state
);
263 int tms_count
= tap_get_tms_path_len(start_state
, goal_state
);
264 assert(tms_count
<= 8);
266 LOG_DEBUG_IO("start=%s goal=%s", tap_state_name(start_state
), tap_state_name(goal_state
));
268 /* Track state transitions step by step */
269 for (int i
= 0; i
< tms_count
; i
++)
270 tap_set_state(tap_state_transition(tap_get_state(), (tms_bits
>> i
) & 1));
272 mpsse_clock_tms_cs_out(mpsse_ctx
,
280 static int ftdi_speed(int speed
)
283 retval
= mpsse_set_frequency(mpsse_ctx
, speed
);
286 LOG_ERROR("couldn't set FTDI TCK speed");
290 if (!swd_mode
&& speed
>= 10000000 && ftdi_jtag_mode
!= JTAG_MODE_ALT
)
291 LOG_INFO("ftdi: if you experience problems at higher adapter clocks, try "
292 "the command \"ftdi tdo_sample_edge falling\"");
296 static int ftdi_speed_div(int speed
, int *khz
)
302 static int ftdi_khz(int khz
, int *jtag_speed
)
304 if (khz
== 0 && !mpsse_is_high_speed(mpsse_ctx
)) {
305 LOG_DEBUG("RCLK not supported");
309 *jtag_speed
= khz
* 1000;
313 static void ftdi_end_state(tap_state_t state
)
315 if (tap_is_state_stable(state
))
316 tap_set_end_state(state
);
318 LOG_ERROR("BUG: %s is not a stable end state", tap_state_name(state
));
323 static void ftdi_execute_runtest(struct jtag_command
*cmd
)
328 LOG_DEBUG_IO("runtest %i cycles, end in %s",
329 cmd
->cmd
.runtest
->num_cycles
,
330 tap_state_name(cmd
->cmd
.runtest
->end_state
));
332 if (tap_get_state() != TAP_IDLE
)
333 move_to_state(TAP_IDLE
);
335 /* TODO: Reuse ftdi_execute_stableclocks */
336 i
= cmd
->cmd
.runtest
->num_cycles
;
338 /* there are no state transitions in this code, so omit state tracking */
339 unsigned this_len
= i
> 7 ? 7 : i
;
340 mpsse_clock_tms_cs_out(mpsse_ctx
, &zero
, 0, this_len
, false, ftdi_jtag_mode
);
344 ftdi_end_state(cmd
->cmd
.runtest
->end_state
);
346 if (tap_get_state() != tap_get_end_state())
347 move_to_state(tap_get_end_state());
349 LOG_DEBUG_IO("runtest: %i, end in %s",
350 cmd
->cmd
.runtest
->num_cycles
,
351 tap_state_name(tap_get_end_state()));
354 static void ftdi_execute_statemove(struct jtag_command
*cmd
)
356 LOG_DEBUG_IO("statemove end in %s",
357 tap_state_name(cmd
->cmd
.statemove
->end_state
));
359 ftdi_end_state(cmd
->cmd
.statemove
->end_state
);
361 /* shortest-path move to desired end state */
362 if (tap_get_state() != tap_get_end_state() || tap_get_end_state() == TAP_RESET
)
363 move_to_state(tap_get_end_state());
367 * Clock a bunch of TMS (or SWDIO) transitions, to change the JTAG
368 * (or SWD) state machine. REVISIT: Not the best method, perhaps.
370 static void ftdi_execute_tms(struct jtag_command
*cmd
)
372 LOG_DEBUG_IO("TMS: %d bits", cmd
->cmd
.tms
->num_bits
);
374 /* TODO: Missing tap state tracking, also missing from ft2232.c! */
375 mpsse_clock_tms_cs_out(mpsse_ctx
,
378 cmd
->cmd
.tms
->num_bits
,
383 static void ftdi_execute_pathmove(struct jtag_command
*cmd
)
385 tap_state_t
*path
= cmd
->cmd
.pathmove
->path
;
386 int num_states
= cmd
->cmd
.pathmove
->num_states
;
388 LOG_DEBUG_IO("pathmove: %i states, current: %s end: %s", num_states
,
389 tap_state_name(tap_get_state()),
390 tap_state_name(path
[num_states
-1]));
393 unsigned bit_count
= 0;
394 uint8_t tms_byte
= 0;
398 /* this loop verifies that the path is legal and logs each state in the path */
399 while (num_states
--) {
401 /* either TMS=0 or TMS=1 must work ... */
402 if (tap_state_transition(tap_get_state(), false)
403 == path
[state_count
])
404 buf_set_u32(&tms_byte
, bit_count
++, 1, 0x0);
405 else if (tap_state_transition(tap_get_state(), true)
406 == path
[state_count
]) {
407 buf_set_u32(&tms_byte
, bit_count
++, 1, 0x1);
409 /* ... or else the caller goofed BADLY */
411 LOG_ERROR("BUG: %s -> %s isn't a valid "
412 "TAP state transition",
413 tap_state_name(tap_get_state()),
414 tap_state_name(path
[state_count
]));
418 tap_set_state(path
[state_count
]);
421 if (bit_count
== 7 || num_states
== 0) {
422 mpsse_clock_tms_cs_out(mpsse_ctx
,
431 tap_set_end_state(tap_get_state());
434 static void ftdi_execute_scan(struct jtag_command
*cmd
)
436 LOG_DEBUG_IO("%s type:%d", cmd
->cmd
.scan
->ir_scan
? "IRSCAN" : "DRSCAN",
437 jtag_scan_type(cmd
->cmd
.scan
));
439 /* Make sure there are no trailing fields with num_bits == 0, or the logic below will fail. */
440 while (cmd
->cmd
.scan
->num_fields
> 0
441 && cmd
->cmd
.scan
->fields
[cmd
->cmd
.scan
->num_fields
- 1].num_bits
== 0) {
442 cmd
->cmd
.scan
->num_fields
--;
443 LOG_DEBUG_IO("discarding trailing empty field");
446 if (cmd
->cmd
.scan
->num_fields
== 0) {
447 LOG_DEBUG_IO("empty scan, doing nothing");
451 if (cmd
->cmd
.scan
->ir_scan
) {
452 if (tap_get_state() != TAP_IRSHIFT
)
453 move_to_state(TAP_IRSHIFT
);
455 if (tap_get_state() != TAP_DRSHIFT
)
456 move_to_state(TAP_DRSHIFT
);
459 ftdi_end_state(cmd
->cmd
.scan
->end_state
);
461 struct scan_field
*field
= cmd
->cmd
.scan
->fields
;
462 unsigned scan_size
= 0;
464 for (int i
= 0; i
< cmd
->cmd
.scan
->num_fields
; i
++, field
++) {
465 scan_size
+= field
->num_bits
;
466 LOG_DEBUG_IO("%s%s field %d/%d %d bits",
467 field
->in_value
? "in" : "",
468 field
->out_value
? "out" : "",
470 cmd
->cmd
.scan
->num_fields
,
473 if (i
== cmd
->cmd
.scan
->num_fields
- 1 && tap_get_state() != tap_get_end_state()) {
474 /* Last field, and we're leaving IRSHIFT/DRSHIFT. Clock last bit during tap
475 * movement. This last field can't have length zero, it was checked above. */
476 mpsse_clock_data(mpsse_ctx
,
483 uint8_t last_bit
= 0;
484 if (field
->out_value
)
485 bit_copy(&last_bit
, 0, field
->out_value
, field
->num_bits
- 1, 1);
487 /* If endstate is TAP_IDLE, clock out 1-1-0 (->EXIT1 ->UPDATE ->IDLE)
488 * Otherwise, clock out 1-0 (->EXIT1 ->PAUSE)
490 uint8_t tms_bits
= 0x03;
491 mpsse_clock_tms_cs(mpsse_ctx
,
499 tap_set_state(tap_state_transition(tap_get_state(), 1));
500 if (tap_get_end_state() == TAP_IDLE
) {
501 mpsse_clock_tms_cs_out(mpsse_ctx
,
507 tap_set_state(tap_state_transition(tap_get_state(), 1));
508 tap_set_state(tap_state_transition(tap_get_state(), 0));
510 mpsse_clock_tms_cs_out(mpsse_ctx
,
516 tap_set_state(tap_state_transition(tap_get_state(), 0));
519 mpsse_clock_data(mpsse_ctx
,
528 if (tap_get_state() != tap_get_end_state())
529 move_to_state(tap_get_end_state());
531 LOG_DEBUG_IO("%s scan, %i bits, end in %s",
532 (cmd
->cmd
.scan
->ir_scan
) ? "IR" : "DR", scan_size
,
533 tap_state_name(tap_get_end_state()));
536 static int ftdi_reset(int trst
, int srst
)
538 struct signal
*sig_ntrst
= find_signal_by_name("nTRST");
539 struct signal
*sig_nsrst
= find_signal_by_name("nSRST");
541 LOG_DEBUG_IO("reset trst: %i srst %i", trst
, srst
);
546 ftdi_set_signal(sig_ntrst
, '0');
548 LOG_ERROR("Can't assert TRST: nTRST signal is not defined");
549 } else if (sig_ntrst
&& jtag_get_reset_config() & RESET_HAS_TRST
&&
551 if (jtag_get_reset_config() & RESET_TRST_OPEN_DRAIN
)
552 ftdi_set_signal(sig_ntrst
, 'z');
554 ftdi_set_signal(sig_ntrst
, '1');
560 ftdi_set_signal(sig_nsrst
, '0');
562 LOG_ERROR("Can't assert SRST: nSRST signal is not defined");
563 } else if (sig_nsrst
&& jtag_get_reset_config() & RESET_HAS_SRST
&&
565 if (jtag_get_reset_config() & RESET_SRST_PUSH_PULL
)
566 ftdi_set_signal(sig_nsrst
, '1');
568 ftdi_set_signal(sig_nsrst
, 'z');
571 return mpsse_flush(mpsse_ctx
);
574 static void ftdi_execute_sleep(struct jtag_command
*cmd
)
576 LOG_DEBUG_IO("sleep %" PRIu32
, cmd
->cmd
.sleep
->us
);
578 mpsse_flush(mpsse_ctx
);
579 jtag_sleep(cmd
->cmd
.sleep
->us
);
580 LOG_DEBUG_IO("sleep %" PRIu32
" usec while in %s",
582 tap_state_name(tap_get_state()));
585 static void ftdi_execute_stableclocks(struct jtag_command
*cmd
)
587 /* this is only allowed while in a stable state. A check for a stable
588 * state was done in jtag_add_clocks()
590 int num_cycles
= cmd
->cmd
.stableclocks
->num_cycles
;
592 /* 7 bits of either ones or zeros. */
593 uint8_t tms
= tap_get_state() == TAP_RESET
? 0x7f : 0x00;
595 /* TODO: Use mpsse_clock_data with in=out=0 for this, if TMS can be set to
596 * the correct level and remain there during the scan */
597 while (num_cycles
> 0) {
598 /* there are no state transitions in this code, so omit state tracking */
599 unsigned this_len
= num_cycles
> 7 ? 7 : num_cycles
;
600 mpsse_clock_tms_cs_out(mpsse_ctx
, &tms
, 0, this_len
, false, ftdi_jtag_mode
);
601 num_cycles
-= this_len
;
604 LOG_DEBUG_IO("clocks %i while in %s",
605 cmd
->cmd
.stableclocks
->num_cycles
,
606 tap_state_name(tap_get_state()));
609 static void ftdi_execute_command(struct jtag_command
*cmd
)
613 ftdi_execute_runtest(cmd
);
616 ftdi_execute_statemove(cmd
);
619 ftdi_execute_pathmove(cmd
);
622 ftdi_execute_scan(cmd
);
625 ftdi_execute_sleep(cmd
);
627 case JTAG_STABLECLOCKS
:
628 ftdi_execute_stableclocks(cmd
);
631 ftdi_execute_tms(cmd
);
634 LOG_ERROR("BUG: unknown JTAG command type encountered: %d", cmd
->type
);
639 static int ftdi_execute_queue(void)
641 /* blink, if the current layout has that feature */
642 struct signal
*led
= find_signal_by_name("LED");
644 ftdi_set_signal(led
, '1');
646 for (struct jtag_command
*cmd
= jtag_command_queue
; cmd
; cmd
= cmd
->next
) {
647 /* fill the write buffer with the desired command */
648 ftdi_execute_command(cmd
);
652 ftdi_set_signal(led
, '0');
654 int retval
= mpsse_flush(mpsse_ctx
);
655 if (retval
!= ERROR_OK
)
656 LOG_ERROR("error while flushing MPSSE queue: %d", retval
);
661 static int ftdi_initialize(void)
663 if (tap_get_tms_path_len(TAP_IRPAUSE
, TAP_IRPAUSE
) == 7)
664 LOG_DEBUG("ftdi interface using 7 step jtag state transitions");
666 LOG_DEBUG("ftdi interface using shortest path jtag state transitions");
668 if (!ftdi_vid
[0] && !ftdi_pid
[0]) {
669 LOG_ERROR("Please specify ftdi vid_pid");
670 return ERROR_JTAG_INIT_FAILED
;
673 for (int i
= 0; ftdi_vid
[i
] || ftdi_pid
[i
]; i
++) {
674 mpsse_ctx
= mpsse_open(&ftdi_vid
[i
], &ftdi_pid
[i
], ftdi_device_desc
,
675 ftdi_serial
, jtag_usb_get_location(), ftdi_channel
);
681 return ERROR_JTAG_INIT_FAILED
;
683 output
= jtag_output_init
;
684 direction
= jtag_direction_init
;
687 struct signal
*sig
= find_signal_by_name("SWD_EN");
689 LOG_ERROR("SWD mode is active but SWD_EN signal is not defined");
690 return ERROR_JTAG_INIT_FAILED
;
692 /* A dummy SWD_EN would have zero mask */
694 ftdi_set_signal(sig
, '1');
697 mpsse_set_data_bits_low_byte(mpsse_ctx
, output
& 0xff, direction
& 0xff);
698 mpsse_set_data_bits_high_byte(mpsse_ctx
, output
>> 8, direction
>> 8);
700 mpsse_loopback_config(mpsse_ctx
, false);
702 freq
= mpsse_set_frequency(mpsse_ctx
, jtag_get_speed_khz() * 1000);
704 return mpsse_flush(mpsse_ctx
);
707 static int ftdi_quit(void)
709 mpsse_close(mpsse_ctx
);
711 struct signal
*sig
= signals
;
713 struct signal
*next
= sig
->next
;
714 free((void *)sig
->name
);
719 free(ftdi_device_desc
);
727 COMMAND_HANDLER(ftdi_handle_device_desc_command
)
730 free(ftdi_device_desc
);
731 ftdi_device_desc
= strdup(CMD_ARGV
[0]);
733 LOG_ERROR("expected exactly one argument to ftdi device_desc <description>");
739 COMMAND_HANDLER(ftdi_handle_serial_command
)
743 ftdi_serial
= strdup(CMD_ARGV
[0]);
745 return ERROR_COMMAND_SYNTAX_ERROR
;
751 COMMAND_HANDLER(ftdi_handle_channel_command
)
754 COMMAND_PARSE_NUMBER(u8
, CMD_ARGV
[0], ftdi_channel
);
756 return ERROR_COMMAND_SYNTAX_ERROR
;
761 COMMAND_HANDLER(ftdi_handle_layout_init_command
)
764 return ERROR_COMMAND_SYNTAX_ERROR
;
766 COMMAND_PARSE_NUMBER(u16
, CMD_ARGV
[0], jtag_output_init
);
767 COMMAND_PARSE_NUMBER(u16
, CMD_ARGV
[1], jtag_direction_init
);
772 COMMAND_HANDLER(ftdi_handle_layout_signal_command
)
775 return ERROR_COMMAND_SYNTAX_ERROR
;
777 bool invert_data
= false;
778 uint16_t data_mask
= 0;
779 bool invert_input
= false;
780 uint16_t input_mask
= 0;
781 bool invert_oe
= false;
782 uint16_t oe_mask
= 0;
783 for (unsigned i
= 1; i
< CMD_ARGC
; i
+= 2) {
784 if (strcmp("-data", CMD_ARGV
[i
]) == 0) {
786 COMMAND_PARSE_NUMBER(u16
, CMD_ARGV
[i
+ 1], data_mask
);
787 } else if (strcmp("-ndata", CMD_ARGV
[i
]) == 0) {
789 COMMAND_PARSE_NUMBER(u16
, CMD_ARGV
[i
+ 1], data_mask
);
790 } else if (strcmp("-input", CMD_ARGV
[i
]) == 0) {
791 invert_input
= false;
792 COMMAND_PARSE_NUMBER(u16
, CMD_ARGV
[i
+ 1], input_mask
);
793 } else if (strcmp("-ninput", CMD_ARGV
[i
]) == 0) {
795 COMMAND_PARSE_NUMBER(u16
, CMD_ARGV
[i
+ 1], input_mask
);
796 } else if (strcmp("-oe", CMD_ARGV
[i
]) == 0) {
798 COMMAND_PARSE_NUMBER(u16
, CMD_ARGV
[i
+ 1], oe_mask
);
799 } else if (strcmp("-noe", CMD_ARGV
[i
]) == 0) {
801 COMMAND_PARSE_NUMBER(u16
, CMD_ARGV
[i
+ 1], oe_mask
);
802 } else if (!strcmp("-alias", CMD_ARGV
[i
]) ||
803 !strcmp("-nalias", CMD_ARGV
[i
])) {
804 if (!strcmp("-nalias", CMD_ARGV
[i
])) {
808 struct signal
*sig
= find_signal_by_name(CMD_ARGV
[i
+ 1]);
810 LOG_ERROR("signal %s is not defined", CMD_ARGV
[i
+ 1]);
813 data_mask
= sig
->data_mask
;
814 input_mask
= sig
->input_mask
;
815 oe_mask
= sig
->oe_mask
;
816 invert_input
^= sig
->invert_input
;
817 invert_oe
= sig
->invert_oe
;
818 invert_data
^= sig
->invert_data
;
820 LOG_ERROR("unknown option '%s'", CMD_ARGV
[i
]);
821 return ERROR_COMMAND_SYNTAX_ERROR
;
826 sig
= find_signal_by_name(CMD_ARGV
[0]);
828 sig
= create_signal(CMD_ARGV
[0]);
830 LOG_ERROR("failed to create signal %s", CMD_ARGV
[0]);
834 sig
->invert_data
= invert_data
;
835 sig
->data_mask
= data_mask
;
836 sig
->invert_input
= invert_input
;
837 sig
->input_mask
= input_mask
;
838 sig
->invert_oe
= invert_oe
;
839 sig
->oe_mask
= oe_mask
;
844 COMMAND_HANDLER(ftdi_handle_set_signal_command
)
847 return ERROR_COMMAND_SYNTAX_ERROR
;
850 sig
= find_signal_by_name(CMD_ARGV
[0]);
852 LOG_ERROR("interface configuration doesn't define signal '%s'", CMD_ARGV
[0]);
856 switch (*CMD_ARGV
[1]) {
861 /* single character level specifier only */
862 if (CMD_ARGV
[1][1] == '\0') {
863 ftdi_set_signal(sig
, *CMD_ARGV
[1]);
868 LOG_ERROR("unknown signal level '%s', use 0, 1 or z", CMD_ARGV
[1]);
869 return ERROR_COMMAND_SYNTAX_ERROR
;
872 return mpsse_flush(mpsse_ctx
);
875 COMMAND_HANDLER(ftdi_handle_get_signal_command
)
878 return ERROR_COMMAND_SYNTAX_ERROR
;
881 uint16_t sig_data
= 0;
882 sig
= find_signal_by_name(CMD_ARGV
[0]);
884 LOG_ERROR("interface configuration doesn't define signal '%s'", CMD_ARGV
[0]);
888 int ret
= ftdi_get_signal(sig
, &sig_data
);
892 LOG_USER("Signal %s = %#06x", sig
->name
, sig_data
);
897 COMMAND_HANDLER(ftdi_handle_vid_pid_command
)
899 if (CMD_ARGC
> MAX_USB_IDS
* 2) {
900 LOG_WARNING("ignoring extra IDs in ftdi vid_pid "
901 "(maximum is %d pairs)", MAX_USB_IDS
);
902 CMD_ARGC
= MAX_USB_IDS
* 2;
904 if (CMD_ARGC
< 2 || (CMD_ARGC
& 1)) {
905 LOG_WARNING("incomplete ftdi vid_pid configuration directive");
907 return ERROR_COMMAND_SYNTAX_ERROR
;
908 /* remove the incomplete trailing id */
913 for (i
= 0; i
< CMD_ARGC
; i
+= 2) {
914 COMMAND_PARSE_NUMBER(u16
, CMD_ARGV
[i
], ftdi_vid
[i
>> 1]);
915 COMMAND_PARSE_NUMBER(u16
, CMD_ARGV
[i
+ 1], ftdi_pid
[i
>> 1]);
919 * Explicitly terminate, in case there are multiples instances of
922 ftdi_vid
[i
>> 1] = ftdi_pid
[i
>> 1] = 0;
927 COMMAND_HANDLER(ftdi_handle_tdo_sample_edge_command
)
930 static const struct jim_nvp nvp_ftdi_jtag_modes
[] = {
931 { .name
= "rising", .value
= JTAG_MODE
},
932 { .name
= "falling", .value
= JTAG_MODE_ALT
},
933 { .name
= NULL
, .value
= -1 },
937 n
= jim_nvp_name2value_simple(nvp_ftdi_jtag_modes
, CMD_ARGV
[0]);
939 return ERROR_COMMAND_SYNTAX_ERROR
;
940 ftdi_jtag_mode
= n
->value
;
944 n
= jim_nvp_value2name_simple(nvp_ftdi_jtag_modes
, ftdi_jtag_mode
);
945 command_print(CMD
, "ftdi samples TDO on %s edge of TCK", n
->name
);
950 static const struct command_registration ftdi_subcommand_handlers
[] = {
952 .name
= "device_desc",
953 .handler
= &ftdi_handle_device_desc_command
,
954 .mode
= COMMAND_CONFIG
,
955 .help
= "set the USB device description of the FTDI device",
956 .usage
= "description_string",
960 .handler
= &ftdi_handle_serial_command
,
961 .mode
= COMMAND_CONFIG
,
962 .help
= "set the serial number of the FTDI device",
963 .usage
= "serial_string",
967 .handler
= &ftdi_handle_channel_command
,
968 .mode
= COMMAND_CONFIG
,
969 .help
= "set the channel of the FTDI device that is used as JTAG",
973 .name
= "layout_init",
974 .handler
= &ftdi_handle_layout_init_command
,
975 .mode
= COMMAND_CONFIG
,
976 .help
= "initialize the FTDI GPIO signals used "
977 "to control output-enables and reset signals",
978 .usage
= "data direction",
981 .name
= "layout_signal",
982 .handler
= &ftdi_handle_layout_signal_command
,
984 .help
= "define a signal controlled by one or more FTDI GPIO as data "
985 "and/or output enable",
986 .usage
= "name [-data mask|-ndata mask] [-oe mask|-noe mask] [-alias|-nalias name]",
989 .name
= "set_signal",
990 .handler
= &ftdi_handle_set_signal_command
,
991 .mode
= COMMAND_EXEC
,
992 .help
= "control a layout-specific signal",
993 .usage
= "name (1|0|z)",
996 .name
= "get_signal",
997 .handler
= &ftdi_handle_get_signal_command
,
998 .mode
= COMMAND_EXEC
,
999 .help
= "read the value of a layout-specific signal",
1004 .handler
= &ftdi_handle_vid_pid_command
,
1005 .mode
= COMMAND_CONFIG
,
1006 .help
= "the vendor ID and product ID of the FTDI device",
1007 .usage
= "(vid pid)*",
1010 .name
= "tdo_sample_edge",
1011 .handler
= &ftdi_handle_tdo_sample_edge_command
,
1012 .mode
= COMMAND_ANY
,
1013 .help
= "set which TCK clock edge is used for sampling TDO "
1014 "- default is rising-edge (Setting to falling-edge may "
1015 "allow signalling speed increase)",
1016 .usage
= "(rising|falling)",
1018 COMMAND_REGISTRATION_DONE
1021 static const struct command_registration ftdi_command_handlers
[] = {
1024 .mode
= COMMAND_ANY
,
1025 .help
= "perform ftdi management",
1026 .chain
= ftdi_subcommand_handlers
,
1029 COMMAND_REGISTRATION_DONE
1032 static int create_default_signal(const char *name
, uint16_t data_mask
)
1034 struct signal
*sig
= create_signal(name
);
1036 LOG_ERROR("failed to create signal %s", name
);
1039 sig
->invert_data
= false;
1040 sig
->data_mask
= data_mask
;
1041 sig
->invert_oe
= false;
1047 static int create_signals(void)
1049 if (create_default_signal("TCK", 0x01) != ERROR_OK
)
1051 if (create_default_signal("TDI", 0x02) != ERROR_OK
)
1053 if (create_default_signal("TDO", 0x04) != ERROR_OK
)
1055 if (create_default_signal("TMS", 0x08) != ERROR_OK
)
1060 static int ftdi_swd_init(void)
1062 LOG_INFO("FTDI SWD mode enabled");
1065 if (create_signals() != ERROR_OK
)
1068 swd_cmd_queue_alloced
= 10;
1069 swd_cmd_queue
= malloc(swd_cmd_queue_alloced
* sizeof(*swd_cmd_queue
));
1071 return swd_cmd_queue
? ERROR_OK
: ERROR_FAIL
;
1074 static void ftdi_swd_swdio_en(bool enable
)
1076 struct signal
*oe
= find_signal_by_name("SWDIO_OE");
1079 ftdi_set_signal(oe
, enable
? '1' : '0');
1081 /* Sets TDI/DO pin to input during rx when both pins are connected
1084 direction
|= jtag_direction_init
& 0x0002U
;
1086 direction
&= ~0x0002U
;
1087 mpsse_set_data_bits_low_byte(mpsse_ctx
, output
& 0xff, direction
& 0xff);
1093 * Flush the MPSSE queue and process the SWD transaction queue
1096 static int ftdi_swd_run_queue(void)
1098 LOG_DEBUG_IO("Executing %zu queued transactions", swd_cmd_queue_length
);
1100 struct signal
*led
= find_signal_by_name("LED");
1102 if (queued_retval
!= ERROR_OK
) {
1103 LOG_DEBUG_IO("Skipping due to previous errors: %d", queued_retval
);
1107 /* A transaction must be followed by another transaction or at least 8 idle cycles to
1108 * ensure that data is clocked through the AP. */
1109 mpsse_clock_data_out(mpsse_ctx
, NULL
, 0, 8, SWD_MODE
);
1111 /* Terminate the "blink", if the current layout has that feature */
1113 ftdi_set_signal(led
, '0');
1115 queued_retval
= mpsse_flush(mpsse_ctx
);
1116 if (queued_retval
!= ERROR_OK
) {
1117 LOG_ERROR("MPSSE failed");
1121 for (size_t i
= 0; i
< swd_cmd_queue_length
; i
++) {
1122 int ack
= buf_get_u32(swd_cmd_queue
[i
].trn_ack_data_parity_trn
, 1, 3);
1124 LOG_DEBUG_IO("%s %s %s reg %X = %08"PRIx32
,
1125 ack
== SWD_ACK_OK
? "OK" : ack
== SWD_ACK_WAIT
? "WAIT" : ack
== SWD_ACK_FAULT
? "FAULT" : "JUNK",
1126 swd_cmd_queue
[i
].cmd
& SWD_CMD_APNDP
? "AP" : "DP",
1127 swd_cmd_queue
[i
].cmd
& SWD_CMD_RNW
? "read" : "write",
1128 (swd_cmd_queue
[i
].cmd
& SWD_CMD_A32
) >> 1,
1129 buf_get_u32(swd_cmd_queue
[i
].trn_ack_data_parity_trn
,
1130 1 + 3 + (swd_cmd_queue
[i
].cmd
& SWD_CMD_RNW
? 0 : 1), 32));
1132 if (ack
!= SWD_ACK_OK
) {
1133 queued_retval
= ack
== SWD_ACK_WAIT
? ERROR_WAIT
: ERROR_FAIL
;
1136 } else if (swd_cmd_queue
[i
].cmd
& SWD_CMD_RNW
) {
1137 uint32_t data
= buf_get_u32(swd_cmd_queue
[i
].trn_ack_data_parity_trn
, 1 + 3, 32);
1138 int parity
= buf_get_u32(swd_cmd_queue
[i
].trn_ack_data_parity_trn
, 1 + 3 + 32, 1);
1140 if (parity
!= parity_u32(data
)) {
1141 LOG_ERROR("SWD Read data parity mismatch");
1142 queued_retval
= ERROR_FAIL
;
1146 if (swd_cmd_queue
[i
].dst
)
1147 *swd_cmd_queue
[i
].dst
= data
;
1152 swd_cmd_queue_length
= 0;
1153 retval
= queued_retval
;
1154 queued_retval
= ERROR_OK
;
1156 /* Queue a new "blink" */
1157 if (led
&& retval
== ERROR_OK
)
1158 ftdi_set_signal(led
, '1');
1163 static void ftdi_swd_queue_cmd(uint8_t cmd
, uint32_t *dst
, uint32_t data
, uint32_t ap_delay_clk
)
1165 if (swd_cmd_queue_length
>= swd_cmd_queue_alloced
) {
1166 /* Not enough room in the queue. Run the queue and increase its size for next time.
1167 * Note that it's not possible to avoid running the queue here, because mpsse contains
1168 * pointers into the queue which may be invalid after the realloc. */
1169 queued_retval
= ftdi_swd_run_queue();
1170 struct swd_cmd_queue_entry
*q
= realloc(swd_cmd_queue
, swd_cmd_queue_alloced
* 2 * sizeof(*swd_cmd_queue
));
1173 swd_cmd_queue_alloced
*= 2;
1174 LOG_DEBUG("Increased SWD command queue to %zu elements", swd_cmd_queue_alloced
);
1178 if (queued_retval
!= ERROR_OK
)
1181 size_t i
= swd_cmd_queue_length
++;
1182 swd_cmd_queue
[i
].cmd
= cmd
| SWD_CMD_START
| SWD_CMD_PARK
;
1184 mpsse_clock_data_out(mpsse_ctx
, &swd_cmd_queue
[i
].cmd
, 0, 8, SWD_MODE
);
1186 if (swd_cmd_queue
[i
].cmd
& SWD_CMD_RNW
) {
1187 /* Queue a read transaction */
1188 swd_cmd_queue
[i
].dst
= dst
;
1190 ftdi_swd_swdio_en(false);
1191 mpsse_clock_data_in(mpsse_ctx
, swd_cmd_queue
[i
].trn_ack_data_parity_trn
,
1192 0, 1 + 3 + 32 + 1 + 1, SWD_MODE
);
1193 ftdi_swd_swdio_en(true);
1195 /* Queue a write transaction */
1196 ftdi_swd_swdio_en(false);
1198 mpsse_clock_data_in(mpsse_ctx
, swd_cmd_queue
[i
].trn_ack_data_parity_trn
,
1199 0, 1 + 3 + 1, SWD_MODE
);
1201 ftdi_swd_swdio_en(true);
1203 buf_set_u32(swd_cmd_queue
[i
].trn_ack_data_parity_trn
, 1 + 3 + 1, 32, data
);
1204 buf_set_u32(swd_cmd_queue
[i
].trn_ack_data_parity_trn
, 1 + 3 + 1 + 32, 1, parity_u32(data
));
1206 mpsse_clock_data_out(mpsse_ctx
, swd_cmd_queue
[i
].trn_ack_data_parity_trn
,
1207 1 + 3 + 1, 32 + 1, SWD_MODE
);
1210 /* Insert idle cycles after AP accesses to avoid WAIT */
1211 if (cmd
& SWD_CMD_APNDP
)
1212 mpsse_clock_data_out(mpsse_ctx
, NULL
, 0, ap_delay_clk
, SWD_MODE
);
1216 static void ftdi_swd_read_reg(uint8_t cmd
, uint32_t *value
, uint32_t ap_delay_clk
)
1218 assert(cmd
& SWD_CMD_RNW
);
1219 ftdi_swd_queue_cmd(cmd
, value
, 0, ap_delay_clk
);
1222 static void ftdi_swd_write_reg(uint8_t cmd
, uint32_t value
, uint32_t ap_delay_clk
)
1224 assert(!(cmd
& SWD_CMD_RNW
));
1225 ftdi_swd_queue_cmd(cmd
, NULL
, value
, ap_delay_clk
);
1228 static int ftdi_swd_switch_seq(enum swd_special_seq seq
)
1232 LOG_DEBUG("SWD line reset");
1233 ftdi_swd_swdio_en(true);
1234 mpsse_clock_data_out(mpsse_ctx
, swd_seq_line_reset
, 0, swd_seq_line_reset_len
, SWD_MODE
);
1237 LOG_DEBUG("JTAG-to-SWD");
1238 ftdi_swd_swdio_en(true);
1239 mpsse_clock_data_out(mpsse_ctx
, swd_seq_jtag_to_swd
, 0, swd_seq_jtag_to_swd_len
, SWD_MODE
);
1242 LOG_DEBUG("SWD-to-JTAG");
1243 ftdi_swd_swdio_en(true);
1244 mpsse_clock_data_out(mpsse_ctx
, swd_seq_swd_to_jtag
, 0, swd_seq_swd_to_jtag_len
, SWD_MODE
);
1247 LOG_ERROR("Sequence %d not supported", seq
);
1254 static const struct swd_driver ftdi_swd
= {
1255 .init
= ftdi_swd_init
,
1256 .switch_seq
= ftdi_swd_switch_seq
,
1257 .read_reg
= ftdi_swd_read_reg
,
1258 .write_reg
= ftdi_swd_write_reg
,
1259 .run
= ftdi_swd_run_queue
,
1262 static const char * const ftdi_transports
[] = { "jtag", "swd", NULL
};
1264 static struct jtag_interface ftdi_interface
= {
1265 .supported
= DEBUG_CAP_TMS_SEQ
,
1266 .execute_queue
= ftdi_execute_queue
,
1269 struct adapter_driver ftdi_adapter_driver
= {
1271 .transports
= ftdi_transports
,
1272 .commands
= ftdi_command_handlers
,
1274 .init
= ftdi_initialize
,
1276 .reset
= ftdi_reset
,
1277 .speed
= ftdi_speed
,
1279 .speed_div
= ftdi_speed_div
,
1281 .jtag_ops
= &ftdi_interface
,
1282 .swd_ops
= &ftdi_swd
,
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)