OpenOCD
ftdi.c
Go to the documentation of this file.
1 // SPDX-License-Identifier: GPL-2.0-or-later
2 
3 /**************************************************************************
4 * Copyright (C) 2012 by Andreas Fritiofson *
5 * andreas.fritiofson@gmail.com *
6 ***************************************************************************/
7 
56 #ifdef HAVE_CONFIG_H
57 #include "config.h"
58 #endif
59 
60 /* project specific includes */
61 #include <jtag/adapter.h>
62 #include <jtag/interface.h>
63 #include <jtag/swd.h>
64 #include <transport/transport.h>
65 #include <helper/time_support.h>
66 #include <helper/log.h>
67 
68 #if IS_CYGWIN == 1
69 #include <windows.h>
70 #endif
71 
72 #include <assert.h>
73 
74 /* FTDI access library includes */
75 #include "mpsse.h"
76 
77 #define JTAG_MODE (LSB_FIRST | POS_EDGE_IN | NEG_EDGE_OUT)
78 #define JTAG_MODE_ALT (LSB_FIRST | NEG_EDGE_IN | NEG_EDGE_OUT)
79 #define SWD_MODE (LSB_FIRST | POS_EDGE_IN | NEG_EDGE_OUT)
80 
81 static char *ftdi_device_desc;
82 static uint8_t ftdi_channel;
83 static uint8_t ftdi_jtag_mode = JTAG_MODE;
84 
85 static bool swd_mode;
86 
87 #define MAX_USB_IDS 8
88 /* vid = pid = 0 marks the end of the list */
89 static uint16_t ftdi_vid[MAX_USB_IDS + 1] = { 0 };
90 static uint16_t ftdi_pid[MAX_USB_IDS + 1] = { 0 };
91 
92 static struct mpsse_ctx *mpsse_ctx;
93 
94 struct signal {
95  const char *name;
96  uint16_t data_mask;
97  uint16_t input_mask;
98  uint16_t oe_mask;
101  bool invert_oe;
102  struct signal *next;
103 };
104 
105 static struct signal *signals;
106 
107 /* FIXME: Where to store per-instance data? We need an SWD context. */
108 static struct swd_cmd_queue_entry {
109  uint8_t cmd;
110  uint32_t *dst;
111  uint8_t trn_ack_data_parity_trn[DIV_ROUND_UP(4 + 3 + 32 + 1 + 4, 8)];
113 static size_t swd_cmd_queue_length;
114 static size_t swd_cmd_queue_alloced;
115 static int queued_retval;
116 static int freq;
117 
118 static uint16_t output;
119 static uint16_t direction;
120 static uint16_t jtag_output_init;
121 static uint16_t jtag_direction_init;
122 
123 static int ftdi_swd_switch_seq(enum swd_special_seq seq);
124 
125 static struct signal *find_signal_by_name(const char *name)
126 {
127  for (struct signal *sig = signals; sig; sig = sig->next) {
128  if (strcmp(name, sig->name) == 0)
129  return sig;
130  }
131  return NULL;
132 }
133 
134 static struct signal *create_signal(const char *name)
135 {
136  struct signal **psig = &signals;
137  while (*psig)
138  psig = &(*psig)->next;
139 
140  *psig = calloc(1, sizeof(**psig));
141  if (!*psig)
142  return NULL;
143 
144  (*psig)->name = strdup(name);
145  if (!(*psig)->name) {
146  free(*psig);
147  *psig = NULL;
148  }
149  return *psig;
150 }
151 
152 static int ftdi_set_signal(const struct signal *s, char value)
153 {
154  bool data;
155  bool oe;
156 
157  if (s->data_mask == 0 && s->oe_mask == 0) {
158  LOG_ERROR("interface doesn't provide signal '%s'", s->name);
159  return ERROR_FAIL;
160  }
161  switch (value) {
162  case '0':
163  data = s->invert_data;
164  oe = !s->invert_oe;
165  break;
166  case '1':
167  if (s->data_mask == 0) {
168  LOG_ERROR("interface can't drive '%s' high", s->name);
169  return ERROR_FAIL;
170  }
171  data = !s->invert_data;
172  oe = !s->invert_oe;
173  break;
174  case 'z':
175  case 'Z':
176  if (s->oe_mask == 0) {
177  LOG_ERROR("interface can't tri-state '%s'", s->name);
178  return ERROR_FAIL;
179  }
180  data = s->invert_data;
181  oe = s->invert_oe;
182  break;
183  default:
184  assert(0 && "invalid signal level specifier");
185  return ERROR_FAIL;
186  }
187 
188  uint16_t old_output = output;
189  uint16_t old_direction = direction;
190 
191  output = data ? output | s->data_mask : output & ~s->data_mask;
192  if (s->oe_mask == s->data_mask)
193  direction = oe ? direction | s->oe_mask : direction & ~s->oe_mask;
194  else
195  output = oe ? output | s->oe_mask : output & ~s->oe_mask;
196 
197  if ((output & 0xff) != (old_output & 0xff) || (direction & 0xff) != (old_direction & 0xff))
199  if ((output >> 8 != old_output >> 8) || (direction >> 8 != old_direction >> 8))
201 
202  return ERROR_OK;
203 }
204 
205 static int ftdi_get_signal(const struct signal *s, uint16_t *value_out)
206 {
207  uint8_t data_low = 0;
208  uint8_t data_high = 0;
209 
210  if (s->input_mask == 0) {
211  LOG_ERROR("interface doesn't provide signal '%s'", s->name);
212  return ERROR_FAIL;
213  }
214 
215  if (s->input_mask & 0xff)
217  if (s->input_mask >> 8)
219 
221 
222  *value_out = (((uint16_t)data_high) << 8) | data_low;
223 
224  if (s->invert_input)
225  *value_out = ~(*value_out);
226 
227  *value_out &= s->input_mask;
228 
229  return ERROR_OK;
230 }
231 
240 static void move_to_state(tap_state_t goal_state)
241 {
242  tap_state_t start_state = tap_get_state();
243 
244  /* goal_state is 1/2 of a tuple/pair of states which allow convenient
245  lookup of the required TMS pattern to move to this state from the
246  start state.
247  */
248 
249  /* do the 2 lookups */
250  uint8_t tms_bits = tap_get_tms_path(start_state, goal_state);
251  int tms_count = tap_get_tms_path_len(start_state, goal_state);
252  assert(tms_count <= 8);
253 
254  LOG_DEBUG_IO("start=%s goal=%s", tap_state_name(start_state), tap_state_name(goal_state));
255 
256  /* Track state transitions step by step */
257  for (int i = 0; i < tms_count; i++)
258  tap_set_state(tap_state_transition(tap_get_state(), (tms_bits >> i) & 1));
259 
261  &tms_bits,
262  0,
263  tms_count,
264  false,
266 }
267 
268 static int ftdi_speed(int speed)
269 {
270  int retval;
271  retval = mpsse_set_frequency(mpsse_ctx, speed);
272 
273  if (retval < 0) {
274  LOG_ERROR("couldn't set FTDI TCK speed");
275  return retval;
276  }
277 
278  if (!swd_mode && speed >= 10000000 && ftdi_jtag_mode != JTAG_MODE_ALT)
279  LOG_INFO("ftdi: if you experience problems at higher adapter clocks, try "
280  "the command \"ftdi tdo_sample_edge falling\"");
281  return ERROR_OK;
282 }
283 
284 static int ftdi_speed_div(int speed, int *khz)
285 {
286  *khz = speed / 1000;
287  return ERROR_OK;
288 }
289 
290 static int ftdi_khz(int khz, int *jtag_speed)
291 {
292  if (khz == 0 && !mpsse_is_high_speed(mpsse_ctx)) {
293  LOG_DEBUG("RCLK not supported");
294  return ERROR_FAIL;
295  }
296 
297  *jtag_speed = khz * 1000;
298  return ERROR_OK;
299 }
300 
302 {
305  else {
306  LOG_ERROR("BUG: %s is not a stable end state", tap_state_name(state));
307  exit(-1);
308  }
309 }
310 
312 {
313  int i;
314  uint8_t zero = 0;
315 
316  LOG_DEBUG_IO("runtest %i cycles, end in %s",
317  cmd->cmd.runtest->num_cycles,
318  tap_state_name(cmd->cmd.runtest->end_state));
319 
320  if (tap_get_state() != TAP_IDLE)
322 
323  /* TODO: Reuse ftdi_execute_stableclocks */
324  i = cmd->cmd.runtest->num_cycles;
325  while (i > 0) {
326  /* there are no state transitions in this code, so omit state tracking */
327  unsigned this_len = i > 7 ? 7 : i;
328  mpsse_clock_tms_cs_out(mpsse_ctx, &zero, 0, this_len, false, ftdi_jtag_mode);
329  i -= this_len;
330  }
331 
332  ftdi_end_state(cmd->cmd.runtest->end_state);
333 
334  if (tap_get_state() != tap_get_end_state())
336 
337  LOG_DEBUG_IO("runtest: %i, end in %s",
338  cmd->cmd.runtest->num_cycles,
340 }
341 
343 {
344  LOG_DEBUG_IO("statemove end in %s",
345  tap_state_name(cmd->cmd.statemove->end_state));
346 
347  ftdi_end_state(cmd->cmd.statemove->end_state);
348 
349  /* shortest-path move to desired end state */
352 }
353 
358 static void ftdi_execute_tms(struct jtag_command *cmd)
359 {
360  LOG_DEBUG_IO("TMS: %d bits", cmd->cmd.tms->num_bits);
361 
362  /* TODO: Missing tap state tracking, also missing from ft2232.c! */
364  cmd->cmd.tms->bits,
365  0,
366  cmd->cmd.tms->num_bits,
367  false,
369 }
370 
372 {
373  tap_state_t *path = cmd->cmd.pathmove->path;
374  int num_states = cmd->cmd.pathmove->num_states;
375 
376  LOG_DEBUG_IO("pathmove: %i states, current: %s end: %s", num_states,
378  tap_state_name(path[num_states-1]));
379 
380  int state_count = 0;
381  unsigned bit_count = 0;
382  uint8_t tms_byte = 0;
383 
384  LOG_DEBUG_IO("-");
385 
386  /* this loop verifies that the path is legal and logs each state in the path */
387  while (num_states--) {
388 
389  /* either TMS=0 or TMS=1 must work ... */
390  if (tap_state_transition(tap_get_state(), false)
391  == path[state_count])
392  buf_set_u32(&tms_byte, bit_count++, 1, 0x0);
393  else if (tap_state_transition(tap_get_state(), true)
394  == path[state_count]) {
395  buf_set_u32(&tms_byte, bit_count++, 1, 0x1);
396 
397  /* ... or else the caller goofed BADLY */
398  } else {
399  LOG_ERROR("BUG: %s -> %s isn't a valid "
400  "TAP state transition",
402  tap_state_name(path[state_count]));
403  exit(-1);
404  }
405 
406  tap_set_state(path[state_count]);
407  state_count++;
408 
409  if (bit_count == 7 || num_states == 0) {
411  &tms_byte,
412  0,
413  bit_count,
414  false,
416  bit_count = 0;
417  }
418  }
420 }
421 
422 static void ftdi_execute_scan(struct jtag_command *cmd)
423 {
424  LOG_DEBUG_IO("%s type:%d", cmd->cmd.scan->ir_scan ? "IRSCAN" : "DRSCAN",
425  jtag_scan_type(cmd->cmd.scan));
426 
427  /* Make sure there are no trailing fields with num_bits == 0, or the logic below will fail. */
428  while (cmd->cmd.scan->num_fields > 0
429  && cmd->cmd.scan->fields[cmd->cmd.scan->num_fields - 1].num_bits == 0) {
430  cmd->cmd.scan->num_fields--;
431  LOG_DEBUG_IO("discarding trailing empty field");
432  }
433 
434  if (cmd->cmd.scan->num_fields == 0) {
435  LOG_DEBUG_IO("empty scan, doing nothing");
436  return;
437  }
438 
439  if (cmd->cmd.scan->ir_scan) {
440  if (tap_get_state() != TAP_IRSHIFT)
442  } else {
443  if (tap_get_state() != TAP_DRSHIFT)
445  }
446 
447  ftdi_end_state(cmd->cmd.scan->end_state);
448 
449  struct scan_field *field = cmd->cmd.scan->fields;
450  unsigned scan_size = 0;
451 
452  for (int i = 0; i < cmd->cmd.scan->num_fields; i++, field++) {
453  scan_size += field->num_bits;
454  LOG_DEBUG_IO("%s%s field %d/%d %d bits",
455  field->in_value ? "in" : "",
456  field->out_value ? "out" : "",
457  i,
458  cmd->cmd.scan->num_fields,
459  field->num_bits);
460 
461  if (i == cmd->cmd.scan->num_fields - 1 && tap_get_state() != tap_get_end_state()) {
462  /* Last field, and we're leaving IRSHIFT/DRSHIFT. Clock last bit during tap
463  * movement. This last field can't have length zero, it was checked above. */
465  field->out_value,
466  0,
467  field->in_value,
468  0,
469  field->num_bits - 1,
471  uint8_t last_bit = 0;
472  if (field->out_value)
473  bit_copy(&last_bit, 0, field->out_value, field->num_bits - 1, 1);
474 
475  /* If endstate is TAP_IDLE, clock out 1-1-0 (->EXIT1 ->UPDATE ->IDLE)
476  * Otherwise, clock out 1-0 (->EXIT1 ->PAUSE)
477  */
478  uint8_t tms_bits = 0x03;
480  &tms_bits,
481  0,
482  field->in_value,
483  field->num_bits - 1,
484  1,
485  last_bit,
488  if (tap_get_end_state() == TAP_IDLE) {
490  &tms_bits,
491  1,
492  2,
493  last_bit,
497  } else {
499  &tms_bits,
500  2,
501  1,
502  last_bit,
505  }
506  } else
508  field->out_value,
509  0,
510  field->in_value,
511  0,
512  field->num_bits,
514  }
515 
516  if (tap_get_state() != tap_get_end_state())
518 
519  LOG_DEBUG_IO("%s scan, %i bits, end in %s",
520  (cmd->cmd.scan->ir_scan) ? "IR" : "DR", scan_size,
522 }
523 
524 static int ftdi_reset(int trst, int srst)
525 {
526  struct signal *sig_ntrst = find_signal_by_name("nTRST");
527  struct signal *sig_nsrst = find_signal_by_name("nSRST");
528 
529  LOG_DEBUG_IO("reset trst: %i srst %i", trst, srst);
530 
531  if (!swd_mode) {
532  if (trst == 1) {
533  if (sig_ntrst)
534  ftdi_set_signal(sig_ntrst, '0');
535  else
536  LOG_ERROR("Can't assert TRST: nTRST signal is not defined");
537  } else if (sig_ntrst && jtag_get_reset_config() & RESET_HAS_TRST &&
538  trst == 0) {
540  ftdi_set_signal(sig_ntrst, 'z');
541  else
542  ftdi_set_signal(sig_ntrst, '1');
543  }
544  }
545 
546  if (srst == 1) {
547  if (sig_nsrst)
548  ftdi_set_signal(sig_nsrst, '0');
549  else
550  LOG_ERROR("Can't assert SRST: nSRST signal is not defined");
551  } else if (sig_nsrst && jtag_get_reset_config() & RESET_HAS_SRST &&
552  srst == 0) {
554  ftdi_set_signal(sig_nsrst, '1');
555  else
556  ftdi_set_signal(sig_nsrst, 'z');
557  }
558 
559  return mpsse_flush(mpsse_ctx);
560 }
561 
562 static void ftdi_execute_sleep(struct jtag_command *cmd)
563 {
564  LOG_DEBUG_IO("sleep %" PRIu32, cmd->cmd.sleep->us);
565 
567  jtag_sleep(cmd->cmd.sleep->us);
568  LOG_DEBUG_IO("sleep %" PRIu32 " usec while in %s",
569  cmd->cmd.sleep->us,
571 }
572 
574 {
575  /* this is only allowed while in a stable state. A check for a stable
576  * state was done in jtag_add_clocks()
577  */
578  int num_cycles = cmd->cmd.stableclocks->num_cycles;
579 
580  /* 7 bits of either ones or zeros. */
581  uint8_t tms = tap_get_state() == TAP_RESET ? 0x7f : 0x00;
582 
583  /* TODO: Use mpsse_clock_data with in=out=0 for this, if TMS can be set to
584  * the correct level and remain there during the scan */
585  while (num_cycles > 0) {
586  /* there are no state transitions in this code, so omit state tracking */
587  unsigned this_len = num_cycles > 7 ? 7 : num_cycles;
588  mpsse_clock_tms_cs_out(mpsse_ctx, &tms, 0, this_len, false, ftdi_jtag_mode);
589  num_cycles -= this_len;
590  }
591 
592  LOG_DEBUG_IO("clocks %i while in %s",
593  cmd->cmd.stableclocks->num_cycles,
595 }
596 
598 {
599  switch (cmd->type) {
600  case JTAG_RUNTEST:
602  break;
603  case JTAG_TLR_RESET:
605  break;
606  case JTAG_PATHMOVE:
608  break;
609  case JTAG_SCAN:
611  break;
612  case JTAG_SLEEP:
614  break;
615  case JTAG_STABLECLOCKS:
617  break;
618  case JTAG_TMS:
620  break;
621  default:
622  LOG_ERROR("BUG: unknown JTAG command type encountered: %d", cmd->type);
623  break;
624  }
625 }
626 
627 static int ftdi_execute_queue(void)
628 {
629  /* blink, if the current layout has that feature */
630  struct signal *led = find_signal_by_name("LED");
631  if (led)
632  ftdi_set_signal(led, '1');
633 
634  for (struct jtag_command *cmd = jtag_command_queue; cmd; cmd = cmd->next) {
635  /* fill the write buffer with the desired command */
637  }
638 
639  if (led)
640  ftdi_set_signal(led, '0');
641 
642  int retval = mpsse_flush(mpsse_ctx);
643  if (retval != ERROR_OK)
644  LOG_ERROR("error while flushing MPSSE queue: %d", retval);
645 
646  return retval;
647 }
648 
649 static int ftdi_initialize(void)
650 {
652  LOG_DEBUG("ftdi interface using 7 step jtag state transitions");
653  else
654  LOG_DEBUG("ftdi interface using shortest path jtag state transitions");
655 
656  if (!ftdi_vid[0] && !ftdi_pid[0]) {
657  LOG_ERROR("Please specify ftdi vid_pid");
658  return ERROR_JTAG_INIT_FAILED;
659  }
660 
661  for (int i = 0; ftdi_vid[i] || ftdi_pid[i]; i++) {
664  if (mpsse_ctx)
665  break;
666  }
667 
668  if (!mpsse_ctx)
669  return ERROR_JTAG_INIT_FAILED;
670 
673 
674  if (swd_mode) {
675  struct signal *sig = find_signal_by_name("SWD_EN");
676  if (!sig) {
677  LOG_ERROR("SWD mode is active but SWD_EN signal is not defined");
678  return ERROR_JTAG_INIT_FAILED;
679  }
680  /* A dummy SWD_EN would have zero mask */
681  if (sig->data_mask)
682  ftdi_set_signal(sig, '1');
683  }
684 
687 
689 
691 
692  return mpsse_flush(mpsse_ctx);
693 }
694 
695 static int ftdi_quit(void)
696 {
698 
699  struct signal *sig = signals;
700  while (sig) {
701  struct signal *next = sig->next;
702  free((void *)sig->name);
703  free(sig);
704  sig = next;
705  }
706 
707  free(ftdi_device_desc);
708 
709  free(swd_cmd_queue);
710 
711  return ERROR_OK;
712 }
713 
714 COMMAND_HANDLER(ftdi_handle_device_desc_command)
715 {
716  if (CMD_ARGC == 1) {
717  free(ftdi_device_desc);
718  ftdi_device_desc = strdup(CMD_ARGV[0]);
719  } else {
720  LOG_ERROR("expected exactly one argument to ftdi device_desc <description>");
721  }
722 
723  return ERROR_OK;
724 }
725 
726 COMMAND_HANDLER(ftdi_handle_channel_command)
727 {
728  if (CMD_ARGC == 1)
730  else
732 
733  return ERROR_OK;
734 }
735 
736 COMMAND_HANDLER(ftdi_handle_layout_init_command)
737 {
738  if (CMD_ARGC != 2)
740 
743 
744  return ERROR_OK;
745 }
746 
747 COMMAND_HANDLER(ftdi_handle_layout_signal_command)
748 {
749  if (CMD_ARGC < 1)
751 
752  bool invert_data = false;
753  uint16_t data_mask = 0;
754  bool invert_input = false;
755  uint16_t input_mask = 0;
756  bool invert_oe = false;
757  uint16_t oe_mask = 0;
758  for (unsigned i = 1; i < CMD_ARGC; i += 2) {
759  if (strcmp("-data", CMD_ARGV[i]) == 0) {
760  invert_data = false;
762  } else if (strcmp("-ndata", CMD_ARGV[i]) == 0) {
763  invert_data = true;
765  } else if (strcmp("-input", CMD_ARGV[i]) == 0) {
766  invert_input = false;
768  } else if (strcmp("-ninput", CMD_ARGV[i]) == 0) {
769  invert_input = true;
771  } else if (strcmp("-oe", CMD_ARGV[i]) == 0) {
772  invert_oe = false;
773  COMMAND_PARSE_NUMBER(u16, CMD_ARGV[i + 1], oe_mask);
774  } else if (strcmp("-noe", CMD_ARGV[i]) == 0) {
775  invert_oe = true;
776  COMMAND_PARSE_NUMBER(u16, CMD_ARGV[i + 1], oe_mask);
777  } else if (!strcmp("-alias", CMD_ARGV[i]) ||
778  !strcmp("-nalias", CMD_ARGV[i])) {
779  if (!strcmp("-nalias", CMD_ARGV[i])) {
780  invert_data = true;
781  invert_input = true;
782  }
783  struct signal *sig = find_signal_by_name(CMD_ARGV[i + 1]);
784  if (!sig) {
785  LOG_ERROR("signal %s is not defined", CMD_ARGV[i + 1]);
786  return ERROR_FAIL;
787  }
788  data_mask = sig->data_mask;
789  input_mask = sig->input_mask;
790  oe_mask = sig->oe_mask;
791  invert_input ^= sig->invert_input;
792  invert_oe = sig->invert_oe;
793  invert_data ^= sig->invert_data;
794  } else {
795  LOG_ERROR("unknown option '%s'", CMD_ARGV[i]);
797  }
798  }
799 
800  struct signal *sig;
801  sig = find_signal_by_name(CMD_ARGV[0]);
802  if (!sig)
803  sig = create_signal(CMD_ARGV[0]);
804  if (!sig) {
805  LOG_ERROR("failed to create signal %s", CMD_ARGV[0]);
806  return ERROR_FAIL;
807  }
808 
809  sig->invert_data = invert_data;
810  sig->data_mask = data_mask;
811  sig->invert_input = invert_input;
812  sig->input_mask = input_mask;
813  sig->invert_oe = invert_oe;
814  sig->oe_mask = oe_mask;
815 
816  return ERROR_OK;
817 }
818 
819 COMMAND_HANDLER(ftdi_handle_set_signal_command)
820 {
821  if (CMD_ARGC < 2)
823 
824  struct signal *sig;
825  sig = find_signal_by_name(CMD_ARGV[0]);
826  if (!sig) {
827  LOG_ERROR("interface configuration doesn't define signal '%s'", CMD_ARGV[0]);
828  return ERROR_FAIL;
829  }
830 
831  switch (*CMD_ARGV[1]) {
832  case '0':
833  case '1':
834  case 'z':
835  case 'Z':
836  /* single character level specifier only */
837  if (CMD_ARGV[1][1] == '\0') {
838  ftdi_set_signal(sig, *CMD_ARGV[1]);
839  break;
840  }
841  /* fallthrough */
842  default:
843  LOG_ERROR("unknown signal level '%s', use 0, 1 or z", CMD_ARGV[1]);
845  }
846 
847  return mpsse_flush(mpsse_ctx);
848 }
849 
850 COMMAND_HANDLER(ftdi_handle_get_signal_command)
851 {
852  if (CMD_ARGC < 1)
854 
855  struct signal *sig;
856  uint16_t sig_data = 0;
857  sig = find_signal_by_name(CMD_ARGV[0]);
858  if (!sig) {
859  LOG_ERROR("interface configuration doesn't define signal '%s'", CMD_ARGV[0]);
860  return ERROR_FAIL;
861  }
862 
863  int ret = ftdi_get_signal(sig, &sig_data);
864  if (ret != ERROR_OK)
865  return ret;
866 
867  LOG_USER("Signal %s = %#06x", sig->name, sig_data);
868 
869  return ERROR_OK;
870 }
871 
872 COMMAND_HANDLER(ftdi_handle_vid_pid_command)
873 {
874  if (CMD_ARGC > MAX_USB_IDS * 2) {
875  LOG_WARNING("ignoring extra IDs in ftdi vid_pid "
876  "(maximum is %d pairs)", MAX_USB_IDS);
877  CMD_ARGC = MAX_USB_IDS * 2;
878  }
879  if (CMD_ARGC < 2 || (CMD_ARGC & 1)) {
880  LOG_WARNING("incomplete ftdi vid_pid configuration directive");
881  if (CMD_ARGC < 2)
883  /* remove the incomplete trailing id */
884  CMD_ARGC -= 1;
885  }
886 
887  unsigned i;
888  for (i = 0; i < CMD_ARGC; i += 2) {
889  COMMAND_PARSE_NUMBER(u16, CMD_ARGV[i], ftdi_vid[i >> 1]);
890  COMMAND_PARSE_NUMBER(u16, CMD_ARGV[i + 1], ftdi_pid[i >> 1]);
891  }
892 
893  /*
894  * Explicitly terminate, in case there are multiples instances of
895  * ftdi vid_pid.
896  */
897  ftdi_vid[i >> 1] = ftdi_pid[i >> 1] = 0;
898 
899  return ERROR_OK;
900 }
901 
902 COMMAND_HANDLER(ftdi_handle_tdo_sample_edge_command)
903 {
904  struct jim_nvp *n;
905  static const struct jim_nvp nvp_ftdi_jtag_modes[] = {
906  { .name = "rising", .value = JTAG_MODE },
907  { .name = "falling", .value = JTAG_MODE_ALT },
908  { .name = NULL, .value = -1 },
909  };
910 
911  if (CMD_ARGC > 0) {
912  n = jim_nvp_name2value_simple(nvp_ftdi_jtag_modes, CMD_ARGV[0]);
913  if (!n->name)
915  ftdi_jtag_mode = n->value;
916 
917  }
918 
919  n = jim_nvp_value2name_simple(nvp_ftdi_jtag_modes, ftdi_jtag_mode);
920  command_print(CMD, "ftdi samples TDO on %s edge of TCK", n->name);
921 
922  return ERROR_OK;
923 }
924 
925 static const struct command_registration ftdi_subcommand_handlers[] = {
926  {
927  .name = "device_desc",
928  .handler = &ftdi_handle_device_desc_command,
929  .mode = COMMAND_CONFIG,
930  .help = "set the USB device description of the FTDI device",
931  .usage = "description_string",
932  },
933  {
934  .name = "channel",
935  .handler = &ftdi_handle_channel_command,
936  .mode = COMMAND_CONFIG,
937  .help = "set the channel of the FTDI device that is used as JTAG",
938  .usage = "(0-3)",
939  },
940  {
941  .name = "layout_init",
942  .handler = &ftdi_handle_layout_init_command,
943  .mode = COMMAND_CONFIG,
944  .help = "initialize the FTDI GPIO signals used "
945  "to control output-enables and reset signals",
946  .usage = "data direction",
947  },
948  {
949  .name = "layout_signal",
950  .handler = &ftdi_handle_layout_signal_command,
951  .mode = COMMAND_ANY,
952  .help = "define a signal controlled by one or more FTDI GPIO as data "
953  "and/or output enable",
954  .usage = "name [-data mask|-ndata mask] [-oe mask|-noe mask] [-alias|-nalias name]",
955  },
956  {
957  .name = "set_signal",
958  .handler = &ftdi_handle_set_signal_command,
959  .mode = COMMAND_EXEC,
960  .help = "control a layout-specific signal",
961  .usage = "name (1|0|z)",
962  },
963  {
964  .name = "get_signal",
965  .handler = &ftdi_handle_get_signal_command,
966  .mode = COMMAND_EXEC,
967  .help = "read the value of a layout-specific signal",
968  .usage = "name",
969  },
970  {
971  .name = "vid_pid",
972  .handler = &ftdi_handle_vid_pid_command,
973  .mode = COMMAND_CONFIG,
974  .help = "the vendor ID and product ID of the FTDI device",
975  .usage = "(vid pid)*",
976  },
977  {
978  .name = "tdo_sample_edge",
979  .handler = &ftdi_handle_tdo_sample_edge_command,
980  .mode = COMMAND_ANY,
981  .help = "set which TCK clock edge is used for sampling TDO "
982  "- default is rising-edge (Setting to falling-edge may "
983  "allow signalling speed increase)",
984  .usage = "(rising|falling)",
985  },
987 };
988 
989 static const struct command_registration ftdi_command_handlers[] = {
990  {
991  .name = "ftdi",
992  .mode = COMMAND_ANY,
993  .help = "perform ftdi management",
994  .chain = ftdi_subcommand_handlers,
995  .usage = "",
996  },
998 };
999 
1000 static int create_default_signal(const char *name, uint16_t data_mask)
1001 {
1002  struct signal *sig = create_signal(name);
1003  if (!sig) {
1004  LOG_ERROR("failed to create signal %s", name);
1005  return ERROR_FAIL;
1006  }
1007  sig->invert_data = false;
1008  sig->data_mask = data_mask;
1009  sig->invert_oe = false;
1010  sig->oe_mask = 0;
1011 
1012  return ERROR_OK;
1013 }
1014 
1015 static int create_signals(void)
1016 {
1017  if (create_default_signal("TCK", 0x01) != ERROR_OK)
1018  return ERROR_FAIL;
1019  if (create_default_signal("TDI", 0x02) != ERROR_OK)
1020  return ERROR_FAIL;
1021  if (create_default_signal("TDO", 0x04) != ERROR_OK)
1022  return ERROR_FAIL;
1023  if (create_default_signal("TMS", 0x08) != ERROR_OK)
1024  return ERROR_FAIL;
1025  return ERROR_OK;
1026 }
1027 
1028 static int ftdi_swd_init(void)
1029 {
1030  LOG_INFO("FTDI SWD mode enabled");
1031  swd_mode = true;
1032 
1033  if (create_signals() != ERROR_OK)
1034  return ERROR_FAIL;
1035 
1036  swd_cmd_queue_alloced = 10;
1037  swd_cmd_queue = malloc(swd_cmd_queue_alloced * sizeof(*swd_cmd_queue));
1038 
1039  return swd_cmd_queue ? ERROR_OK : ERROR_FAIL;
1040 }
1041 
1042 static void ftdi_swd_swdio_en(bool enable)
1043 {
1044  struct signal *oe = find_signal_by_name("SWDIO_OE");
1045  if (oe) {
1046  if (oe->data_mask)
1047  ftdi_set_signal(oe, enable ? '1' : '0');
1048  else {
1049  /* Sets TDI/DO pin to input during rx when both pins are connected
1050  to SWDIO */
1051  if (enable)
1052  direction |= jtag_direction_init & 0x0002U;
1053  else
1054  direction &= ~0x0002U;
1056  }
1057  }
1058 }
1059 
1064 static int ftdi_swd_run_queue(void)
1065 {
1066  LOG_DEBUG_IO("Executing %zu queued transactions", swd_cmd_queue_length);
1067  int retval;
1068  struct signal *led = find_signal_by_name("LED");
1069 
1070  if (queued_retval != ERROR_OK) {
1071  LOG_DEBUG_IO("Skipping due to previous errors: %d", queued_retval);
1072  goto skip;
1073  }
1074 
1075  /* A transaction must be followed by another transaction or at least 8 idle cycles to
1076  * ensure that data is clocked through the AP. */
1078 
1079  /* Terminate the "blink", if the current layout has that feature */
1080  if (led)
1081  ftdi_set_signal(led, '0');
1082 
1084  if (queued_retval != ERROR_OK) {
1085  LOG_ERROR("MPSSE failed");
1086  goto skip;
1087  }
1088 
1089  for (size_t i = 0; i < swd_cmd_queue_length; i++) {
1090  int ack = buf_get_u32(swd_cmd_queue[i].trn_ack_data_parity_trn, 1, 3);
1091 
1092  /* Devices do not reply to DP_TARGETSEL write cmd, ignore received ack */
1093  bool check_ack = swd_cmd_returns_ack(swd_cmd_queue[i].cmd);
1094 
1095  LOG_DEBUG_IO("%s%s %s %s reg %X = %08"PRIx32,
1096  check_ack ? "" : "ack ignored ",
1097  ack == SWD_ACK_OK ? "OK" : ack == SWD_ACK_WAIT ? "WAIT" : ack == SWD_ACK_FAULT ? "FAULT" : "JUNK",
1098  swd_cmd_queue[i].cmd & SWD_CMD_APNDP ? "AP" : "DP",
1099  swd_cmd_queue[i].cmd & SWD_CMD_RNW ? "read" : "write",
1100  (swd_cmd_queue[i].cmd & SWD_CMD_A32) >> 1,
1101  buf_get_u32(swd_cmd_queue[i].trn_ack_data_parity_trn,
1102  1 + 3 + (swd_cmd_queue[i].cmd & SWD_CMD_RNW ? 0 : 1), 32));
1103 
1104  if (ack != SWD_ACK_OK && check_ack) {
1106  goto skip;
1107 
1108  } else if (swd_cmd_queue[i].cmd & SWD_CMD_RNW) {
1109  uint32_t data = buf_get_u32(swd_cmd_queue[i].trn_ack_data_parity_trn, 1 + 3, 32);
1110  int parity = buf_get_u32(swd_cmd_queue[i].trn_ack_data_parity_trn, 1 + 3 + 32, 1);
1111 
1112  if (parity != parity_u32(data)) {
1113  LOG_ERROR("SWD Read data parity mismatch");
1115  goto skip;
1116  }
1117 
1118  if (swd_cmd_queue[i].dst)
1119  *swd_cmd_queue[i].dst = data;
1120  }
1121  }
1122 
1123 skip:
1125  retval = queued_retval;
1127 
1128  /* Queue a new "blink" */
1129  if (led && retval == ERROR_OK)
1130  ftdi_set_signal(led, '1');
1131 
1132  return retval;
1133 }
1134 
1135 static void ftdi_swd_queue_cmd(uint8_t cmd, uint32_t *dst, uint32_t data, uint32_t ap_delay_clk)
1136 {
1138  /* Not enough room in the queue. Run the queue and increase its size for next time.
1139  * Note that it's not possible to avoid running the queue here, because mpsse contains
1140  * pointers into the queue which may be invalid after the realloc. */
1142  struct swd_cmd_queue_entry *q = realloc(swd_cmd_queue, swd_cmd_queue_alloced * 2 * sizeof(*swd_cmd_queue));
1143  if (q) {
1144  swd_cmd_queue = q;
1145  swd_cmd_queue_alloced *= 2;
1146  LOG_DEBUG("Increased SWD command queue to %zu elements", swd_cmd_queue_alloced);
1147  }
1148  }
1149 
1150  if (queued_retval != ERROR_OK)
1151  return;
1152 
1153  size_t i = swd_cmd_queue_length++;
1155 
1157 
1158  if (swd_cmd_queue[i].cmd & SWD_CMD_RNW) {
1159  /* Queue a read transaction */
1160  swd_cmd_queue[i].dst = dst;
1161 
1162  ftdi_swd_swdio_en(false);
1164  0, 1 + 3 + 32 + 1 + 1, SWD_MODE);
1165  ftdi_swd_swdio_en(true);
1166  } else {
1167  /* Queue a write transaction */
1168  ftdi_swd_swdio_en(false);
1169 
1171  0, 1 + 3 + 1, SWD_MODE);
1172 
1173  ftdi_swd_swdio_en(true);
1174 
1175  buf_set_u32(swd_cmd_queue[i].trn_ack_data_parity_trn, 1 + 3 + 1, 32, data);
1176  buf_set_u32(swd_cmd_queue[i].trn_ack_data_parity_trn, 1 + 3 + 1 + 32, 1, parity_u32(data));
1177 
1179  1 + 3 + 1, 32 + 1, SWD_MODE);
1180  }
1181 
1182  /* Insert idle cycles after AP accesses to avoid WAIT */
1183  if (cmd & SWD_CMD_APNDP)
1184  mpsse_clock_data_out(mpsse_ctx, NULL, 0, ap_delay_clk, SWD_MODE);
1185 
1186 }
1187 
1188 static void ftdi_swd_read_reg(uint8_t cmd, uint32_t *value, uint32_t ap_delay_clk)
1189 {
1190  assert(cmd & SWD_CMD_RNW);
1191  ftdi_swd_queue_cmd(cmd, value, 0, ap_delay_clk);
1192 }
1193 
1194 static void ftdi_swd_write_reg(uint8_t cmd, uint32_t value, uint32_t ap_delay_clk)
1195 {
1196  assert(!(cmd & SWD_CMD_RNW));
1197  ftdi_swd_queue_cmd(cmd, NULL, value, ap_delay_clk);
1198 }
1199 
1201 {
1202  switch (seq) {
1203  case LINE_RESET:
1204  LOG_DEBUG("SWD line reset");
1205  ftdi_swd_swdio_en(true);
1207  break;
1208  case JTAG_TO_SWD:
1209  LOG_DEBUG("JTAG-to-SWD");
1210  ftdi_swd_swdio_en(true);
1212  break;
1213  case JTAG_TO_DORMANT:
1214  LOG_DEBUG("JTAG-to-DORMANT");
1215  ftdi_swd_swdio_en(true);
1217  break;
1218  case SWD_TO_JTAG:
1219  LOG_DEBUG("SWD-to-JTAG");
1220  ftdi_swd_swdio_en(true);
1222  break;
1223  case SWD_TO_DORMANT:
1224  LOG_DEBUG("SWD-to-DORMANT");
1225  ftdi_swd_swdio_en(true);
1227  break;
1228  case DORMANT_TO_SWD:
1229  LOG_DEBUG("DORMANT-to-SWD");
1230  ftdi_swd_swdio_en(true);
1232  break;
1233  case DORMANT_TO_JTAG:
1234  LOG_DEBUG("DORMANT-to-JTAG");
1235  ftdi_swd_swdio_en(true);
1237  break;
1238  default:
1239  LOG_ERROR("Sequence %d not supported", seq);
1240  return ERROR_FAIL;
1241  }
1242 
1243  return ERROR_OK;
1244 }
1245 
1246 static const struct swd_driver ftdi_swd = {
1247  .init = ftdi_swd_init,
1248  .switch_seq = ftdi_swd_switch_seq,
1249  .read_reg = ftdi_swd_read_reg,
1250  .write_reg = ftdi_swd_write_reg,
1251  .run = ftdi_swd_run_queue,
1252 };
1253 
1254 static const char * const ftdi_transports[] = { "jtag", "swd", NULL };
1255 
1256 static struct jtag_interface ftdi_interface = {
1258  .execute_queue = ftdi_execute_queue,
1259 };
1260 
1262  .name = "ftdi",
1263  .transports = ftdi_transports,
1264  .commands = ftdi_command_handlers,
1265 
1266  .init = ftdi_initialize,
1267  .quit = ftdi_quit,
1268  .reset = ftdi_reset,
1269  .speed = ftdi_speed,
1270  .khz = ftdi_khz,
1271  .speed_div = ftdi_speed_div,
1272 
1273  .jtag_ops = &ftdi_interface,
1274  .swd_ops = &ftdi_swd,
1275 };
const char * adapter_get_required_serial(void)
Retrieves the serial number set with command 'adapter serial'.
Definition: adapter.c:299
unsigned int adapter_get_speed_khz(void)
Retrieves the clock speed of the adapter in kHz.
Definition: adapter.c:208
const char * adapter_usb_get_location(void)
Definition: adapter.c:325
#define SWD_ACK_FAULT
Definition: arm_adi_v5.h:33
swd_special_seq
Definition: arm_adi_v5.h:229
@ DORMANT_TO_JTAG
Definition: arm_adi_v5.h:236
@ JTAG_TO_SWD
Definition: arm_adi_v5.h:231
@ DORMANT_TO_SWD
Definition: arm_adi_v5.h:235
@ LINE_RESET
Definition: arm_adi_v5.h:230
@ JTAG_TO_DORMANT
Definition: arm_adi_v5.h:232
@ SWD_TO_DORMANT
Definition: arm_adi_v5.h:234
@ SWD_TO_JTAG
Definition: arm_adi_v5.h:233
#define SWD_ACK_WAIT
Definition: arm_adi_v5.h:32
#define SWD_ACK_OK
Definition: arm_adi_v5.h:31
const char * name
Definition: armv4_5.c:76
static void bit_copy(uint8_t *dst, unsigned dst_offset, const uint8_t *src, unsigned src_offset, unsigned bit_count)
Definition: binarybuffer.h:201
static uint32_t buf_get_u32(const uint8_t *_buffer, unsigned first, unsigned num)
Retrieves num bits from _buffer, starting at the first bit, returning the bits in a 32-bit word.
Definition: binarybuffer.h:98
static void buf_set_u32(uint8_t *_buffer, unsigned first, unsigned num, uint32_t value)
Sets num bits in _buffer, starting at the first bit, using the bits in value.
Definition: binarybuffer.h:30
void command_print(struct command_invocation *cmd, const char *format,...)
Definition: command.c:473
#define CMD
Use this macro to access the command being handled, rather than accessing the variable directly.
Definition: command.h:140
#define CMD_ARGV
Use this macro to access the arguments for the command being handled, rather than accessing the varia...
Definition: command.h:155
#define ERROR_COMMAND_SYNTAX_ERROR
Definition: command.h:385
#define CMD_ARGC
Use this macro to access the number of arguments for the command being handled, rather than accessing...
Definition: command.h:150
#define COMMAND_PARSE_NUMBER(type, in, out)
parses the string in into out as a type, or prints a command error and passes the error code to the c...
Definition: command.h:425
#define COMMAND_REGISTRATION_DONE
Use this as the last entry in an array of command_registration records.
Definition: command.h:247
@ COMMAND_CONFIG
Definition: command.h:41
@ COMMAND_ANY
Definition: command.h:42
@ COMMAND_EXEC
Definition: command.h:40
struct jtag_command * jtag_command_queue
The current queue of jtag_command_s structures.
Definition: commands.c:36
enum scan_type jtag_scan_type(const struct scan_command *cmd)
Definition: commands.c:162
@ JTAG_TLR_RESET
Definition: commands.h:137
@ JTAG_SCAN
Definition: commands.h:129
@ JTAG_PATHMOVE
Definition: commands.h:140
@ JTAG_STABLECLOCKS
Definition: commands.h:142
@ JTAG_RUNTEST
Definition: commands.h:138
@ JTAG_SLEEP
Definition: commands.h:141
@ JTAG_TMS
Definition: commands.h:143
static uint16_t output
Definition: ftdi.c:118
COMMAND_HANDLER(ftdi_handle_device_desc_command)
Definition: ftdi.c:714
static uint8_t ftdi_channel
Definition: ftdi.c:82
static const struct command_registration ftdi_command_handlers[]
Definition: ftdi.c:989
static void ftdi_swd_swdio_en(bool enable)
Definition: ftdi.c:1042
static int queued_retval
Definition: ftdi.c:115
static void ftdi_execute_sleep(struct jtag_command *cmd)
Definition: ftdi.c:562
static int ftdi_execute_queue(void)
Definition: ftdi.c:627
static struct signal * create_signal(const char *name)
Definition: ftdi.c:134
static void ftdi_execute_stableclocks(struct jtag_command *cmd)
Definition: ftdi.c:573
static void ftdi_execute_pathmove(struct jtag_command *cmd)
Definition: ftdi.c:371
static int ftdi_swd_init(void)
Definition: ftdi.c:1028
static uint16_t direction
Definition: ftdi.c:119
static char * ftdi_device_desc
Definition: ftdi.c:81
static void ftdi_swd_read_reg(uint8_t cmd, uint32_t *value, uint32_t ap_delay_clk)
Definition: ftdi.c:1188
static struct jtag_interface ftdi_interface
Definition: ftdi.c:1256
#define JTAG_MODE
Definition: ftdi.c:77
static uint16_t jtag_output_init
Definition: ftdi.c:120
static int ftdi_speed(int speed)
Definition: ftdi.c:268
static int ftdi_get_signal(const struct signal *s, uint16_t *value_out)
Definition: ftdi.c:205
static bool swd_mode
Definition: ftdi.c:85
static size_t swd_cmd_queue_length
Definition: ftdi.c:113
struct adapter_driver ftdi_adapter_driver
Definition: ftdi.c:1261
static const struct swd_driver ftdi_swd
Definition: ftdi.c:1246
static struct mpsse_ctx * mpsse_ctx
Definition: ftdi.c:92
static void ftdi_execute_tms(struct jtag_command *cmd)
Clock a bunch of TMS (or SWDIO) transitions, to change the JTAG (or SWD) state machine.
Definition: ftdi.c:358
#define MAX_USB_IDS
Definition: ftdi.c:87
static size_t swd_cmd_queue_alloced
Definition: ftdi.c:114
static const char *const ftdi_transports[]
Definition: ftdi.c:1254
static int ftdi_reset(int trst, int srst)
Definition: ftdi.c:524
static int ftdi_khz(int khz, int *jtag_speed)
Definition: ftdi.c:290
static int ftdi_speed_div(int speed, int *khz)
Definition: ftdi.c:284
static uint16_t ftdi_pid[MAX_USB_IDS+1]
Definition: ftdi.c:90
static void ftdi_swd_queue_cmd(uint8_t cmd, uint32_t *dst, uint32_t data, uint32_t ap_delay_clk)
Definition: ftdi.c:1135
static int ftdi_swd_run_queue(void)
Flush the MPSSE queue and process the SWD transaction queue.
Definition: ftdi.c:1064
#define JTAG_MODE_ALT
Definition: ftdi.c:78
static uint16_t jtag_direction_init
Definition: ftdi.c:121
static struct signal * find_signal_by_name(const char *name)
Definition: ftdi.c:125
static int ftdi_initialize(void)
Definition: ftdi.c:649
static int ftdi_quit(void)
Definition: ftdi.c:695
#define SWD_MODE
Definition: ftdi.c:79
static void ftdi_end_state(tap_state_t state)
Definition: ftdi.c:301
static void move_to_state(tap_state_t goal_state)
Function move_to_state moves the TAP controller from the current state to a goal_state through a path...
Definition: ftdi.c:240
static void ftdi_execute_statemove(struct jtag_command *cmd)
Definition: ftdi.c:342
static int create_default_signal(const char *name, uint16_t data_mask)
Definition: ftdi.c:1000
static void ftdi_execute_scan(struct jtag_command *cmd)
Definition: ftdi.c:422
static uint8_t ftdi_jtag_mode
Definition: ftdi.c:83
static void ftdi_swd_write_reg(uint8_t cmd, uint32_t value, uint32_t ap_delay_clk)
Definition: ftdi.c:1194
static uint16_t ftdi_vid[MAX_USB_IDS+1]
Definition: ftdi.c:89
static int ftdi_swd_switch_seq(enum swd_special_seq seq)
Definition: ftdi.c:1200
static void ftdi_execute_runtest(struct jtag_command *cmd)
Definition: ftdi.c:311
static int freq
Definition: ftdi.c:116
static int create_signals(void)
Definition: ftdi.c:1015
static const struct command_registration ftdi_subcommand_handlers[]
Definition: ftdi.c:925
static int ftdi_set_signal(const struct signal *s, char value)
Definition: ftdi.c:152
static struct signal * signals
Definition: ftdi.c:105
static struct swd_cmd_queue_entry * swd_cmd_queue
static void ftdi_execute_command(struct jtag_command *cmd)
Definition: ftdi.c:597
bool tap_is_state_stable(tap_state_t astate)
Function tap_is_state_stable returns true if the astate is stable.
Definition: interface.c:200
tap_state_t tap_state_transition(tap_state_t cur_state, bool tms)
Function tap_state_transition takes a current TAP state and returns the next state according to the t...
Definition: interface.c:223
const char * tap_state_name(tap_state_t state)
Function tap_state_name Returns a string suitable for display representing the JTAG tap_state.
Definition: interface.c:344
void tap_set_end_state(tap_state_t new_end_state)
This function sets the state of an "end state follower" which tracks the state that any cable driver ...
Definition: interface.c:48
tap_state_t tap_get_end_state(void)
For more information,.
Definition: interface.c:56
int tap_get_tms_path(tap_state_t from, tap_state_t to)
This function provides a "bit sequence" indicating what has to be done with TMS during a sequence of ...
Definition: interface.c:190
int tap_get_tms_path_len(tap_state_t from, tap_state_t to)
Function int tap_get_tms_path_len returns the total number of bits that represents a TMS path transit...
Definition: interface.c:195
tap_state_t tap_get_state(void)
This function gets the state of the "state follower" which tracks the state of the TAPs connected to ...
Definition: interface.c:37
#define DEBUG_CAP_TMS_SEQ
Definition: interface.h:189
#define tap_set_state(new_state)
This function sets the state of a "state follower" which tracks the state of the TAPs connected to th...
Definition: interface.h:49
struct jim_nvp * jim_nvp_name2value_simple(const struct jim_nvp *p, const char *name)
Definition: jim-nvp.c:45
struct jim_nvp * jim_nvp_value2name_simple(const struct jim_nvp *p, int value)
Definition: jim-nvp.c:123
void jtag_sleep(uint32_t us)
Definition: jtag/core.c:1062
enum reset_types jtag_get_reset_config(void)
Definition: jtag/core.c:1734
@ TAP_RESET
Definition: jtag.h:55
@ TAP_IRSHIFT
Definition: jtag.h:50
@ TAP_IDLE
Definition: jtag.h:52
@ TAP_DRSHIFT
Definition: jtag.h:42
@ TAP_IRPAUSE
Definition: jtag.h:51
#define ERROR_JTAG_INIT_FAILED
Definition: jtag.h:549
@ RESET_HAS_SRST
Definition: jtag.h:215
@ RESET_HAS_TRST
Definition: jtag.h:214
@ RESET_TRST_OPEN_DRAIN
Definition: jtag.h:219
@ RESET_SRST_PUSH_PULL
Definition: jtag.h:220
enum tap_state tap_state_t
Defines JTAG Test Access Port states.
#define LOG_USER(expr ...)
Definition: log.h:126
#define LOG_DEBUG_IO(expr ...)
Definition: log.h:101
#define LOG_WARNING(expr ...)
Definition: log.h:120
#define ERROR_FAIL
Definition: log.h:161
#define LOG_ERROR(expr ...)
Definition: log.h:123
#define LOG_INFO(expr ...)
Definition: log.h:117
#define LOG_DEBUG(expr ...)
Definition: log.h:109
#define ERROR_OK
Definition: log.h:155
int mpsse_flush(struct mpsse_ctx *ctx)
Definition: mpsse.c:833
void mpsse_clock_data_out(struct mpsse_ctx *ctx, const uint8_t *out, unsigned out_offset, unsigned length, uint8_t mode)
Definition: mpsse.c:471
void mpsse_read_data_bits_high_byte(struct mpsse_ctx *ctx, uint8_t *data)
Definition: mpsse.c:661
void mpsse_set_data_bits_high_byte(struct mpsse_ctx *ctx, uint8_t data, uint8_t dir)
Definition: mpsse.c:628
int mpsse_set_frequency(struct mpsse_ctx *ctx, int frequency)
Definition: mpsse.c:736
void mpsse_read_data_bits_low_byte(struct mpsse_ctx *ctx, uint8_t *data)
Definition: mpsse.c:645
struct mpsse_ctx * mpsse_open(const uint16_t *vid, const uint16_t *pid, const char *description, const char *serial, const char *location, int channel)
Definition: mpsse.c:310
void mpsse_clock_data_in(struct mpsse_ctx *ctx, uint8_t *in, unsigned in_offset, unsigned length, uint8_t mode)
Definition: mpsse.c:477
bool mpsse_is_high_speed(struct mpsse_ctx *ctx)
Definition: mpsse.c:404
void mpsse_close(struct mpsse_ctx *ctx)
Definition: mpsse.c:390
void mpsse_loopback_config(struct mpsse_ctx *ctx, bool enable)
Definition: mpsse.c:691
void mpsse_clock_tms_cs(struct mpsse_ctx *ctx, const uint8_t *out, unsigned out_offset, uint8_t *in, unsigned in_offset, unsigned length, bool tdi, uint8_t mode)
Definition: mpsse.c:560
void mpsse_set_data_bits_low_byte(struct mpsse_ctx *ctx, uint8_t data, uint8_t dir)
Definition: mpsse.c:611
void mpsse_clock_tms_cs_out(struct mpsse_ctx *ctx, const uint8_t *out, unsigned out_offset, unsigned length, bool tdi, uint8_t mode)
Definition: mpsse.c:554
void mpsse_clock_data(struct mpsse_ctx *ctx, const uint8_t *out, unsigned out_offset, uint8_t *in, unsigned in_offset, unsigned length, uint8_t mode)
Definition: mpsse.c:483
Represents a driver for a debugging interface.
Definition: interface.h:207
const char *const name
The name of the interface driver.
Definition: interface.h:209
const char * name
Definition: command.h:229
const char * usage
a string listing the options and arguments, required or optional
Definition: command.h:235
Name Value Pairs, aka: NVP.
Definition: jim-nvp.h:59
const char * name
Definition: jim-nvp.h:60
int value
Definition: jim-nvp.h:61
Represents a driver for a debugging interface.
Definition: interface.h:184
unsigned supported
Bit vector listing capabilities exposed by this driver.
Definition: interface.h:188
This structure defines a single scan field in the scan.
Definition: jtag.h:86
int num_bits
The number of bits this field specifies.
Definition: jtag.h:88
uint8_t * in_value
A pointer to a 32-bit memory location for data scanned out.
Definition: jtag.h:92
const uint8_t * out_value
A pointer to value to be scanned into the device.
Definition: jtag.h:90
Definition: ftdi.c:94
struct signal * next
Definition: ftdi.c:102
bool invert_oe
Definition: ftdi.c:101
const char * name
Definition: ftdi.c:95
bool invert_data
Definition: ftdi.c:99
uint16_t input_mask
Definition: ftdi.c:97
uint16_t data_mask
Definition: ftdi.c:96
bool invert_input
Definition: ftdi.c:100
uint16_t oe_mask
Definition: ftdi.c:98
Definition: ftdi.c:108
uint8_t trn_ack_data_parity_trn[DIV_ROUND_UP(4+3+32+1+4, 8)]
Definition: ftdi.c:111
uint8_t cmd
Definition: ftdi.c:109
uint32_t * dst
Definition: ftdi.c:110
int(* init)(void)
Initialize the debug link so it can perform SWD operations.
Definition: swd.h:255
static const unsigned swd_seq_swd_to_jtag_len
Definition: swd.h:144
static const unsigned swd_seq_jtag_to_swd_len
Definition: swd.h:125
static const uint8_t swd_seq_dormant_to_jtag[]
Dormant-to-JTAG sequence.
Definition: swd.h:230
#define SWD_CMD_A32
Definition: swd.h:19
static const uint8_t swd_seq_dormant_to_swd[]
Dormant-to-SWD sequence.
Definition: swd.h:171
static const uint8_t swd_seq_jtag_to_dormant[]
JTAG-to-dormant sequence.
Definition: swd.h:199
static const unsigned swd_seq_dormant_to_swd_len
Definition: swd.h:190
static bool swd_cmd_returns_ack(uint8_t cmd)
Test if we can rely on ACK returned by SWD command.
Definition: swd.h:58
#define SWD_CMD_PARK
Definition: swd.h:22
static int swd_ack_to_error_code(uint8_t ack)
Convert SWD ACK value returned from DP to OpenOCD error code.
Definition: swd.h:72
#define SWD_CMD_APNDP
Definition: swd.h:17
static const unsigned swd_seq_jtag_to_dormant_len
Definition: swd.h:211
#define SWD_CMD_START
Definition: swd.h:16
#define SWD_CMD_RNW
Definition: swd.h:18
static const unsigned swd_seq_dormant_to_jtag_len
Definition: swd.h:244
static const uint8_t swd_seq_line_reset[]
SWD Line reset.
Definition: swd.h:98
static const unsigned swd_seq_line_reset_len
Definition: swd.h:104
static const unsigned swd_seq_swd_to_dormant_len
Definition: swd.h:159
static const uint8_t swd_seq_jtag_to_swd[]
JTAG-to-SWD sequence.
Definition: swd.h:115
static const uint8_t swd_seq_swd_to_jtag[]
SWD-to-JTAG sequence.
Definition: swd.h:136
static const uint8_t swd_seq_swd_to_dormant[]
SWD-to-dormant sequence.
Definition: swd.h:153
#define DIV_ROUND_UP(m, n)
Rounds m up to the nearest multiple of n using division.
Definition: types.h:79
static int parity_u32(uint32_t x)
Calculate the (even) parity of a 32-bit datum.
Definition: types.h:265
#define NULL
Definition: usb.h:16
uint8_t cmd
Definition: vdebug.c:1
uint8_t state[4]
Definition: vdebug.c:21
static unsigned int parity(unsigned int v)
Definition: xscale.c:623