OpenOCD
opendous.c
Go to the documentation of this file.
1 // SPDX-License-Identifier: GPL-2.0-or-later
2 
3 /***************************************************************************
4  * *
5  * Copyright (C) 2009 by Cahya Wirawan <cahya@gmx.at> *
6  * Based on opendous driver by Vladimir Fonov *
7  * *
8  * Copyright (C) 2009 by Vladimir Fonov <vladimir.fonov@gmai.com> *
9  * Based on J-link driver by Juergen Stuber *
10  * *
11  * Copyright (C) 2007 by Juergen Stuber <juergen@jstuber.net> *
12  * based on Dominic Rath's and Benedikt Sauter's usbprog.c *
13  * *
14  * Copyright (C) 2008 by Spencer Oliver *
15  * spen@spen-soft.co.uk *
16  ***************************************************************************/
17 
18 #ifdef HAVE_CONFIG_H
19 #include "config.h"
20 #endif
21 
22 #include <jtag/interface.h>
23 #include <jtag/commands.h>
24 #include "libusb_helper.h"
25 #include <string.h>
26 #include <time.h>
27 
28 #define OPENDOUS_MAX_VIDS_PIDS 4
29 /* define some probes with similar interface */
31  const char *name;
34  uint8_t READ_EP;
35  uint8_t WRITE_EP;
38 };
39 
40 static const struct opendous_probe opendous_probes[] = {
41  {"usbprog-jtag", {0x1781, 0}, {0x0C63, 0}, 0x82, 0x02, 0x00, 510 },
42  {"opendous", {0x1781, 0x03EB, 0}, {0xC0C0, 0x204F, 0}, 0x81, 0x02, 0x00, 360 },
43  {"usbvlab", {0x16C0, 0}, {0x05DC, 0}, 0x81, 0x02, 0x01, 360 },
44  {NULL, {0x0000}, {0x0000}, 0x00, 0x00, 0x00, 0 }
45 };
46 
47 #define OPENDOUS_WRITE_ENDPOINT (opendous_probe->WRITE_EP)
48 #define OPENDOUS_READ_ENDPOINT (opendous_probe->READ_EP)
49 
50 static unsigned int opendous_hw_jtag_version = 1;
51 
52 #define OPENDOUS_USB_TIMEOUT 1000
53 
54 #define OPENDOUS_USB_BUFFER_SIZE (opendous_probe->BUFFERSIZE)
55 #define OPENDOUS_IN_BUFFER_SIZE (OPENDOUS_USB_BUFFER_SIZE)
56 #define OPENDOUS_OUT_BUFFER_SIZE (OPENDOUS_USB_BUFFER_SIZE)
57 
58 /* Global USB buffers */
59 static uint8_t *usb_in_buffer;
60 static uint8_t *usb_out_buffer;
61 
62 /* Constants for OPENDOUS command */
63 
64 #define OPENDOUS_MAX_SPEED 66
65 #define OPENDOUS_MAX_TAP_TRANSMIT ((opendous_probe->BUFFERSIZE)-10)
66 #define OPENDOUS_MAX_INPUT_DATA (OPENDOUS_MAX_TAP_TRANSMIT*4)
67 
68 /* TAP */
69 #define OPENDOUS_TAP_BUFFER_SIZE 65536
70 
71 struct pending_scan_result {
72  int first; /* First bit position in tdo_buffer to read */
73  int length; /* Number of bits to read */
74  struct scan_command *command; /* Corresponding scan command */
75  uint8_t *buffer;
76 };
77 
80 
81 #define MAX_PENDING_SCAN_RESULTS (OPENDOUS_MAX_INPUT_DATA)
82 
83 /* JTAG usb commands */
84 #define JTAG_CMD_TAP_OUTPUT 0x0
85 #define JTAG_CMD_SET_TRST 0x1
86 #define JTAG_CMD_SET_SRST 0x2
87 #define JTAG_CMD_READ_INPUT 0x3
88 #define JTAG_CMD_TAP_OUTPUT_EMU 0x4
89 #define JTAG_CMD_SET_DELAY 0x5
90 #define JTAG_CMD_SET_SRST_TRST 0x6
91 #define JTAG_CMD_READ_CONFIG 0x7
92 
93 /* usbvlab control transfer */
94 #define FUNC_START_BOOTLOADER 30
95 #define FUNC_WRITE_DATA 0x50
96 #define FUNC_READ_DATA 0x51
97 
98 static char *opendous_type;
99 static const struct opendous_probe *opendous_probe;
100 
101 /* External interface functions */
102 static int opendous_execute_queue(void);
103 static int opendous_init(void);
104 static int opendous_quit(void);
105 
106 /* Queue command functions */
108 static void opendous_state_move(void);
109 static void opendous_path_move(int num_states, tap_state_t *path);
110 static void opendous_runtest(int num_cycles);
111 static void opendous_scan(int ir_scan, enum scan_type type, uint8_t *buffer,
112  int scan_size, struct scan_command *command);
113 static void opendous_reset(int trst, int srst);
114 static void opendous_simple_command(uint8_t command, uint8_t _data);
115 static int opendous_get_status(void);
116 
117 /* opendous tap buffer functions */
118 static void opendous_tap_init(void);
119 static int opendous_tap_execute(void);
120 static void opendous_tap_ensure_space(int scans, int bits);
121 static void opendous_tap_append_step(int tms, int tdi);
122 static void opendous_tap_append_scan(int length, uint8_t *buffer, struct scan_command *command);
123 
124 /* opendous lowlevel functions */
126  struct libusb_device_handle *usb_handle;
127 };
128 
129 static struct opendous_jtag *opendous_usb_open(void);
130 static void opendous_usb_close(struct opendous_jtag *opendous_jtag);
131 static int opendous_usb_message(struct opendous_jtag *opendous_jtag, int out_length, int in_length);
132 static int opendous_usb_write(struct opendous_jtag *opendous_jtag, int out_length);
133 static int opendous_usb_read(struct opendous_jtag *opendous_jtag);
134 
135 /* helper functions */
136 static int opendous_get_version_info(void);
137 
138 #ifdef _DEBUG_USB_COMMS_
139 static void opendous_debug_buffer(uint8_t *buffer, int length);
140 #endif
141 
143 
144 /***************************************************************************/
145 /* External interface implementation */
146 
147 COMMAND_HANDLER(opendous_handle_opendous_type_command)
148 {
149  if (CMD_ARGC == 0)
150  return ERROR_OK;
151 
152  /* only if the cable name wasn't overwritten by cmdline */
153  if (!opendous_type) {
154  /* REVISIT first verify that it's listed in cables[] ... */
155  opendous_type = strdup(CMD_ARGV[0]);
156  }
157 
158  /* REVISIT it's probably worth returning the current value ... */
159 
160  return ERROR_OK;
161 }
162 
163 COMMAND_HANDLER(opendous_handle_opendous_info_command)
164 {
166  /* attempt to get status */
168  }
169 
170  return ERROR_OK;
171 }
172 
173 COMMAND_HANDLER(opendous_handle_opendous_hw_jtag_command)
174 {
175  switch (CMD_ARGC) {
176  case 0:
177  command_print(CMD, "opendous hw jtag %i", opendous_hw_jtag_version);
178  break;
179 
180  case 1: {
181  int request_version = atoi(CMD_ARGV[0]);
182  switch (request_version) {
183  case 2:
184  case 3:
185  opendous_hw_jtag_version = request_version;
186  break;
187 
188  default:
190  }
191  break;
192  }
193 
194  default:
196  }
197 
198  return ERROR_OK;
199 }
200 
201 static const struct command_registration opendous_command_handlers[] = {
202  {
203  .name = "opendous_info",
204  .handler = &opendous_handle_opendous_info_command,
205  .mode = COMMAND_EXEC,
206  .help = "show opendous info",
207  .usage = "",
208  },
209  {
210  .name = "opendous_hw_jtag",
211  .handler = &opendous_handle_opendous_hw_jtag_command,
212  .mode = COMMAND_EXEC,
213  .help = "access opendous HW JTAG command version",
214  .usage = "[2|3]",
215  },
216  {
217  .name = "opendous_type",
218  .handler = &opendous_handle_opendous_type_command,
219  .mode = COMMAND_CONFIG,
220  .help = "set opendous type",
221  .usage = "[usbvlab|usbprog-jtag|opendous]",
222  },
224 };
225 
226 static struct jtag_interface opendous_interface = {
228 };
229 
231  .name = "opendous",
232  .transports = jtag_only,
233  .commands = opendous_command_handlers,
234 
235  .init = opendous_init,
236  .quit = opendous_quit,
237 
238  .jtag_ops = &opendous_interface,
239 };
240 
241 static int opendous_execute_queue(void)
242 {
244  int scan_size;
245  enum scan_type type;
246  uint8_t *buffer;
247 
248  while (cmd) {
249  switch (cmd->type) {
250  case JTAG_RUNTEST:
251  LOG_DEBUG_IO("runtest %i cycles, end in %i", cmd->cmd.runtest->num_cycles,
252  cmd->cmd.runtest->end_state);
253 
254  if (cmd->cmd.runtest->end_state != -1)
255  opendous_end_state(cmd->cmd.runtest->end_state);
256  opendous_runtest(cmd->cmd.runtest->num_cycles);
257  break;
258 
259  case JTAG_TLR_RESET:
260  LOG_DEBUG_IO("statemove end in %i", cmd->cmd.statemove->end_state);
261 
262  if (cmd->cmd.statemove->end_state != -1)
263  opendous_end_state(cmd->cmd.statemove->end_state);
265  break;
266 
267  case JTAG_PATHMOVE:
268  LOG_DEBUG_IO("pathmove: %i states, end in %i",
269  cmd->cmd.pathmove->num_states,
270  cmd->cmd.pathmove->path[cmd->cmd.pathmove->num_states - 1]);
271 
272  opendous_path_move(cmd->cmd.pathmove->num_states, cmd->cmd.pathmove->path);
273  break;
274 
275  case JTAG_SCAN:
276  LOG_DEBUG_IO("scan end in %i", cmd->cmd.scan->end_state);
277 
278  if (cmd->cmd.scan->end_state != -1)
279  opendous_end_state(cmd->cmd.scan->end_state);
280 
281  scan_size = jtag_build_buffer(cmd->cmd.scan, &buffer);
282  LOG_DEBUG_IO("scan input, length = %d", scan_size);
283 
284 #ifdef _DEBUG_USB_COMMS_
285  opendous_debug_buffer(buffer, (scan_size + 7) / 8);
286 #endif
287  type = jtag_scan_type(cmd->cmd.scan);
288  opendous_scan(cmd->cmd.scan->ir_scan, type, buffer, scan_size, cmd->cmd.scan);
289  break;
290 
291  case JTAG_RESET:
292  LOG_DEBUG_IO("reset trst: %i srst %i", cmd->cmd.reset->trst, cmd->cmd.reset->srst);
293 
295 
296  if (cmd->cmd.reset->trst == 1)
298  opendous_reset(cmd->cmd.reset->trst, cmd->cmd.reset->srst);
299  break;
300 
301  case JTAG_SLEEP:
302  LOG_DEBUG_IO("sleep %" PRIu32, cmd->cmd.sleep->us);
304  jtag_sleep(cmd->cmd.sleep->us);
305  break;
306 
307  default:
308  LOG_ERROR("BUG: unknown JTAG command type encountered");
309  exit(-1);
310  }
311  cmd = cmd->next;
312  }
313  return opendous_tap_execute();
314 }
315 
316 static int opendous_init(void)
317 {
318  int check_cnt;
319  const struct opendous_probe *cur_opendous_probe;
320 
321  cur_opendous_probe = opendous_probes;
322 
323  if (!opendous_type) {
324  opendous_type = strdup("opendous");
325  LOG_WARNING("No opendous_type specified, using default 'opendous'");
326  }
327 
328  while (cur_opendous_probe->name) {
329  if (strcmp(cur_opendous_probe->name, opendous_type) == 0) {
330  opendous_probe = cur_opendous_probe;
331  break;
332  }
333  cur_opendous_probe++;
334  }
335 
336  if (!opendous_probe) {
337  LOG_ERROR("No matching cable found for %s", opendous_type);
338  return ERROR_JTAG_INIT_FAILED;
339  }
340 
341 
344 
347 
349 
350  if (opendous_jtag_handle == 0) {
351  LOG_ERROR("Cannot find opendous Interface! Please check connection and permissions.");
352  return ERROR_JTAG_INIT_FAILED;
353  }
354 
355  check_cnt = 0;
356  while (check_cnt < 3) {
358  /* attempt to get status */
360  break;
361  }
362 
363  check_cnt++;
364  }
365 
366  LOG_INFO("opendous JTAG Interface ready");
367 
368  opendous_reset(0, 0);
370 
371  return ERROR_OK;
372 }
373 
374 static int opendous_quit(void)
375 {
377 
378  free(usb_out_buffer);
380 
381  free(usb_in_buffer);
383 
386 
387  free(opendous_type);
389 
390  return ERROR_OK;
391 }
392 
393 /***************************************************************************/
394 /* Queue command implementations */
395 
397 {
400  else {
401  LOG_ERROR("BUG: %i is not a valid end state", state);
402  exit(-1);
403  }
404 }
405 
406 /* Goes to the end state. */
408 {
409  int i;
410  int tms = 0;
411  uint8_t tms_scan = tap_get_tms_path(tap_get_state(), tap_get_end_state());
412  uint8_t tms_scan_bits = tap_get_tms_path_len(tap_get_state(), tap_get_end_state());
413 
414  for (i = 0; i < tms_scan_bits; i++) {
415  tms = (tms_scan >> i) & 1;
416  opendous_tap_append_step(tms, 0);
417  }
418 
420 }
421 
422 void opendous_path_move(int num_states, tap_state_t *path)
423 {
424  int i;
425 
426  for (i = 0; i < num_states; i++) {
427  if (path[i] == tap_state_transition(tap_get_state(), false))
429  else if (path[i] == tap_state_transition(tap_get_state(), true))
431  else {
432  LOG_ERROR("BUG: %s -> %s isn't a valid TAP transition",
434  exit(-1);
435  }
436 
437  tap_set_state(path[i]);
438  }
439 
441 }
442 
443 void opendous_runtest(int num_cycles)
444 {
445  int i;
446 
447  tap_state_t saved_end_state = tap_get_end_state();
448 
449  /* only do a state_move when we're not already in IDLE */
450  if (tap_get_state() != TAP_IDLE) {
453  }
454 
455  /* execute num_cycles */
456  for (i = 0; i < num_cycles; i++)
458 
459  /* finish in end_state */
460  opendous_end_state(saved_end_state);
461  if (tap_get_state() != tap_get_end_state())
463 }
464 
465 void opendous_scan(int ir_scan, enum scan_type type, uint8_t *buffer, int scan_size, struct scan_command *command)
466 {
467  tap_state_t saved_end_state;
468 
469  opendous_tap_ensure_space(1, scan_size + 8);
470 
471  saved_end_state = tap_get_end_state();
472 
473  /* Move to appropriate scan state */
475 
476  if (tap_get_state() != tap_get_end_state())
478 
479  opendous_end_state(saved_end_state);
480 
481  /* Scan */
483 
484  /* We are in Exit1, go to Pause */
486 
488 
489  if (tap_get_state() != tap_get_end_state())
491 }
492 
493 void opendous_reset(int trst, int srst)
494 {
495  LOG_DEBUG("trst: %i, srst: %i", trst, srst);
496 
497  /* Signals are active low */
498 #if 0
499  if (srst == 0)
501  else if (srst == 1)
503 
504  if (trst == 0)
506  else if (trst == 1)
508 #endif
509 
510  srst = srst ? 0 : 1;
511  trst = trst ? 0 : 2;
513 }
514 
515 void opendous_simple_command(uint8_t command, uint8_t _data)
516 {
517  int result;
518 
519  LOG_DEBUG_IO("0x%02x 0x%02x", command, _data);
520 
521  usb_out_buffer[0] = 2;
522  usb_out_buffer[1] = 0;
523  usb_out_buffer[2] = command;
524  usb_out_buffer[3] = _data;
525 
527  if (result != 1)
528  LOG_ERROR("opendous command 0x%02x failed (%d)", command, result);
529 }
530 
532 {
533  return ERROR_OK;
534 }
535 
537 {
538  return ERROR_OK;
539 }
540 
541 /***************************************************************************/
542 /* Estick tap functions */
543 
544 static int tap_length;
547 
548 static int last_tms;
549 
551 {
552  tap_length = 0;
554 }
555 
556 void opendous_tap_ensure_space(int scans, int bits)
557 {
559  int available_bits = OPENDOUS_TAP_BUFFER_SIZE / 2 - tap_length;
560 
561  if ((scans > available_scans) || (bits > available_bits))
563 }
564 
565 void opendous_tap_append_step(int tms, int tdi)
566 {
567  last_tms = tms;
568  unsigned char _tms = tms ? 1 : 0;
569  unsigned char _tdi = tdi ? 1 : 0;
570 
572 
573  int tap_index = tap_length / 4;
574  int bits = (tap_length % 4) * 2;
575 
577  if (!bits)
578  tms_buffer[tap_index] = 0;
579 
580  tms_buffer[tap_index] |= (_tdi << bits)|(_tms << (bits + 1));
581  tap_length++;
582  } else
583  LOG_ERROR("opendous_tap_append_step, overflow");
584 }
585 
587 {
588  LOG_DEBUG_IO("append scan, length = %d", length);
589 
591  int i;
592 
597 
598  for (i = 0; i < length; i++)
599  opendous_tap_append_step((i < length-1 ? 0 : 1), (buffer[i / 8] >> (i % 8)) & 1);
601 }
602 
603 /* Pad and send a tap sequence to the device, and receive the answer.
604  * For the purpose of padding we assume that we are in idle or pause state. */
606 {
607  int byte_length;
608  int i, j;
609  int result;
610 
611 #ifdef _DEBUG_USB_COMMS_
612  int byte_length_out;
613 #endif
614 
615  if (tap_length > 0) {
616 
617  /* memset(tdo_buffer,0,OPENDOUS_TAP_BUFFER_SIZE); */
618  /* LOG_INFO("OPENDOUS tap execute %d",tap_length); */
619  byte_length = (tap_length + 3) / 4;
620 
621 #ifdef _DEBUG_USB_COMMS_
622  byte_length_out = (tap_length + 7) / 8;
623  LOG_DEBUG("opendous is sending %d bytes", byte_length);
624 #endif
625 
626  for (j = 0, i = 0; j < byte_length;) {
627 
628  int receive;
629  int transmit = byte_length - j;
630  if (transmit > OPENDOUS_MAX_TAP_TRANSMIT) {
631  transmit = OPENDOUS_MAX_TAP_TRANSMIT;
632  receive = (OPENDOUS_MAX_TAP_TRANSMIT) / 2;
634  } else {
635  usb_out_buffer[2] = JTAG_CMD_TAP_OUTPUT | ((tap_length % 4) << 4);
636  receive = (transmit + 1) / 2;
637  }
638  usb_out_buffer[0] = (transmit + 1) & 0xff;
639  usb_out_buffer[1] = ((transmit + 1) >> 8) & 0xff;
640 
641  memmove(usb_out_buffer + 3, tms_buffer + j, transmit);
642  result = opendous_usb_message(opendous_jtag_handle, 3 + transmit, receive);
643  if (result != receive) {
644  LOG_ERROR("opendous_tap_execute, wrong result %d, expected %d", result, receive);
646  }
647 
648  memmove(tdo_buffer + i, usb_in_buffer, receive);
649  i += receive;
650  j += transmit;
651  }
652 
653 #ifdef _DEBUG_USB_COMMS_
654  LOG_DEBUG("opendous tap result %d", byte_length_out);
655  opendous_debug_buffer(tdo_buffer, byte_length_out);
656 #endif
657 
658  /* LOG_INFO("eStick tap execute %d",tap_length); */
659  for (i = 0; i < pending_scan_results_length; i++) {
660 
662  uint8_t *buffer = pending_scan_result->buffer;
666 
667  /* Copy to buffer */
668  buf_set_buf(tdo_buffer, first, buffer, 0, length);
669 
670  LOG_DEBUG_IO("pending scan result, length = %d", length);
671 
672 #ifdef _DEBUG_USB_COMMS_
673  opendous_debug_buffer(buffer, byte_length_out);
674 #endif
675 
679  }
680 
682  }
683 
685  }
686 
687  return ERROR_OK;
688 }
689 
690 /*****************************************************************************/
691 /* Estick USB low-level functions */
692 
694 {
695  struct opendous_jtag *result;
696 
697  struct libusb_device_handle *devh;
699  return NULL;
700 
702  libusb_claim_interface(devh, 0);
703 
704  result = malloc(sizeof(*result));
705  result->usb_handle = devh;
706  return result;
707 }
708 
710 {
712  free(opendous_jtag);
713 }
714 
715 /* Send a message and receive the reply. */
716 int opendous_usb_message(struct opendous_jtag *opendous_jtag, int out_length, int in_length)
717 {
718  int result;
719 
720  result = opendous_usb_write(opendous_jtag, out_length);
721  if (result == out_length) {
723  if (result == in_length)
724  return result;
725  else {
726  LOG_ERROR("usb_bulk_read failed (requested=%d, result=%d)", in_length, result);
727  return -1;
728  }
729  } else {
730  LOG_ERROR("usb_bulk_write failed (requested=%d, result=%d)", out_length, result);
731  return -1;
732  }
733 }
734 
735 /* Write data from out_buffer to USB. */
736 int opendous_usb_write(struct opendous_jtag *opendous_jtag, int out_length)
737 {
738  int result;
739 
740  if (out_length > OPENDOUS_OUT_BUFFER_SIZE) {
741  LOG_ERROR("opendous_jtag_write illegal out_length=%d (max=%d)", out_length, OPENDOUS_OUT_BUFFER_SIZE);
742  return -1;
743  }
744 
745 #ifdef _DEBUG_USB_COMMS_
746  LOG_DEBUG("USB write begin");
747 #endif
750  LIBUSB_REQUEST_TYPE_VENDOR | LIBUSB_RECIPIENT_DEVICE | LIBUSB_ENDPOINT_OUT,
751  FUNC_WRITE_DATA, 0, 0, (char *) usb_out_buffer, out_length, OPENDOUS_USB_TIMEOUT);
752  } else {
754  (char *)usb_out_buffer, out_length, OPENDOUS_USB_TIMEOUT, &result);
755  }
756 #ifdef _DEBUG_USB_COMMS_
757  LOG_DEBUG("USB write end: %d bytes", result);
758 #endif
759 
760  LOG_DEBUG_IO("opendous_usb_write, out_length = %d, result = %d", out_length, result);
761 
762 #ifdef _DEBUG_USB_COMMS_
763  opendous_debug_buffer(usb_out_buffer, out_length);
764 #endif
765  return result;
766 }
767 
768 /* Read data from USB into in_buffer. */
770 {
771 #ifdef _DEBUG_USB_COMMS_
772  LOG_DEBUG("USB read begin");
773 #endif
774  int result;
777  LIBUSB_REQUEST_TYPE_VENDOR | LIBUSB_RECIPIENT_DEVICE | LIBUSB_ENDPOINT_IN,
779  } else {
782  }
783 #ifdef _DEBUG_USB_COMMS_
784  LOG_DEBUG("USB read end: %d bytes", result);
785 #endif
786  LOG_DEBUG_IO("opendous_usb_read, result = %d", result);
787 
788 #ifdef _DEBUG_USB_COMMS_
789  opendous_debug_buffer(usb_in_buffer, result);
790 #endif
791  return result;
792 }
793 
794 #ifdef _DEBUG_USB_COMMS_
795 #define BYTES_PER_LINE 16
796 
797 void opendous_debug_buffer(uint8_t *buffer, int length)
798 {
799  char line[8 + 3 * BYTES_PER_LINE + 1];
800 
801  for (int i = 0; i < length; i += BYTES_PER_LINE) {
802  int n = snprintf(line, 9, "%04x", i);
803  for (int j = i; j < i + BYTES_PER_LINE && j < length; j++)
804  n += snprintf(line + n, 4, " %02x", buffer[j]);
805  LOG_DEBUG("%s", line);
806  }
807 }
808 #endif
const char *const jtag_only[]
Definition: adapter.c:31
uint32_t bits
Definition: armv4_5.c:359
void * buf_set_buf(const void *_src, unsigned src_start, void *_dst, unsigned dst_start, unsigned len)
Definition: binarybuffer.c:121
#define BYTES_PER_LINE
Definition: buspirate.c:1272
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_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_EXEC
Definition: command.h:40
struct jtag_command * jtag_command_queue
The current queue of jtag_command_s structures.
Definition: commands.c:36
int jtag_build_buffer(const struct scan_command *cmd, uint8_t **buffer)
Definition: commands.c:189
enum scan_type jtag_scan_type(const struct scan_command *cmd)
Definition: commands.c:162
int jtag_read_buffer(uint8_t *buffer, const struct scan_command *cmd)
Definition: commands.c:230
scan_type
The inferred type of a scan_command_s structure, indicating whether the command has the host scan in ...
Definition: commands.h:22
@ JTAG_TLR_RESET
Definition: commands.h:137
@ JTAG_SCAN
Definition: commands.h:129
@ JTAG_PATHMOVE
Definition: commands.h:140
@ JTAG_RUNTEST
Definition: commands.h:138
@ JTAG_SLEEP
Definition: commands.h:141
@ JTAG_RESET
Definition: commands.h:139
uint8_t type
Definition: esp_usb_jtag.c:0
uint8_t length
Definition: esp_usb_jtag.c:1
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 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
void jtag_sleep(uint32_t us)
Definition: jtag/core.c:1062
@ TAP_RESET
Definition: jtag.h:55
@ TAP_DRPAUSE
Definition: jtag.h:43
@ 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_QUEUE_FAILED
Definition: jtag.h:553
#define ERROR_JTAG_INIT_FAILED
Definition: jtag.h:549
enum tap_state tap_state_t
Defines JTAG Test Access Port states.
int jtag_libusb_bulk_write(struct libusb_device_handle *dev, int ep, char *bytes, int size, int timeout, int *transferred)
int jtag_libusb_control_transfer(struct libusb_device_handle *dev, uint8_t request_type, uint8_t request, uint16_t value, uint16_t index, char *bytes, uint16_t size, unsigned int timeout)
int jtag_libusb_set_configuration(struct libusb_device_handle *devh, int configuration)
void jtag_libusb_close(struct libusb_device_handle *dev)
int jtag_libusb_bulk_read(struct libusb_device_handle *dev, int ep, char *bytes, int size, int timeout, int *transferred)
int jtag_libusb_open(const uint16_t vids[], const uint16_t pids[], struct libusb_device_handle **out, adapter_get_alternate_serial_fn adapter_get_alternate_serial)
#define LOG_DEBUG_IO(expr ...)
Definition: log.h:101
#define LOG_WARNING(expr ...)
Definition: log.h:120
#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
#define JTAG_CMD_TAP_OUTPUT
Definition: opendous.c:84
static void opendous_tap_append_step(int tms, int tdi)
Definition: opendous.c:565
static int opendous_quit(void)
Definition: opendous.c:374
#define MAX_PENDING_SCAN_RESULTS
Definition: opendous.c:81
static void opendous_tap_init(void)
Definition: opendous.c:550
static void opendous_reset(int trst, int srst)
Definition: opendous.c:493
#define OPENDOUS_TAP_BUFFER_SIZE
Definition: opendous.c:69
static int opendous_usb_message(struct opendous_jtag *opendous_jtag, int out_length, int in_length)
Definition: opendous.c:716
#define OPENDOUS_USB_TIMEOUT
Definition: opendous.c:52
static int opendous_get_version_info(void)
Definition: opendous.c:536
static int last_tms
Definition: opendous.c:548
static int opendous_init(void)
Definition: opendous.c:316
static const struct opendous_probe * opendous_probe
Definition: opendous.c:99
static void opendous_runtest(int num_cycles)
Definition: opendous.c:443
static int tap_length
Definition: opendous.c:544
static char * opendous_type
Definition: opendous.c:98
#define OPENDOUS_OUT_BUFFER_SIZE
Definition: opendous.c:56
static uint8_t tdo_buffer[OPENDOUS_TAP_BUFFER_SIZE]
Definition: opendous.c:546
static struct opendous_jtag * opendous_usb_open(void)
Definition: opendous.c:693
#define OPENDOUS_MAX_TAP_TRANSMIT
Definition: opendous.c:65
struct adapter_driver opendous_adapter_driver
Definition: opendous.c:230
static struct jtag_interface opendous_interface
Definition: opendous.c:226
static void opendous_end_state(tap_state_t state)
Definition: opendous.c:396
#define OPENDOUS_MAX_VIDS_PIDS
Definition: opendous.c:28
static int opendous_tap_execute(void)
Definition: opendous.c:605
static void opendous_tap_append_scan(int length, uint8_t *buffer, struct scan_command *command)
Definition: opendous.c:586
COMMAND_HANDLER(opendous_handle_opendous_type_command)
Definition: opendous.c:147
static uint8_t * usb_out_buffer
Definition: opendous.c:60
#define JTAG_CMD_SET_SRST
Definition: opendous.c:86
#define JTAG_CMD_SET_TRST
Definition: opendous.c:85
#define FUNC_READ_DATA
Definition: opendous.c:96
#define OPENDOUS_IN_BUFFER_SIZE
Definition: opendous.c:55
static void opendous_usb_close(struct opendous_jtag *opendous_jtag)
Definition: opendous.c:709
#define OPENDOUS_WRITE_ENDPOINT
Definition: opendous.c:47
static const struct command_registration opendous_command_handlers[]
Definition: opendous.c:201
static void opendous_tap_ensure_space(int scans, int bits)
Definition: opendous.c:556
static int opendous_usb_write(struct opendous_jtag *opendous_jtag, int out_length)
Definition: opendous.c:736
static uint8_t tms_buffer[OPENDOUS_TAP_BUFFER_SIZE]
Definition: opendous.c:545
#define OPENDOUS_READ_ENDPOINT
Definition: opendous.c:48
static struct opendous_jtag * opendous_jtag_handle
Definition: opendous.c:142
static const struct opendous_probe opendous_probes[]
Definition: opendous.c:40
static struct pending_scan_result * pending_scan_results_buffer
Definition: opendous.c:79
static uint8_t * usb_in_buffer
Definition: opendous.c:59
static void opendous_simple_command(uint8_t command, uint8_t _data)
Definition: opendous.c:515
#define FUNC_WRITE_DATA
Definition: opendous.c:95
static void opendous_scan(int ir_scan, enum scan_type type, uint8_t *buffer, int scan_size, struct scan_command *command)
Definition: opendous.c:465
static void opendous_path_move(int num_states, tap_state_t *path)
Definition: opendous.c:422
static int opendous_execute_queue(void)
Definition: opendous.c:241
static unsigned int opendous_hw_jtag_version
Definition: opendous.c:50
static int pending_scan_results_length
Definition: opendous.c:78
static int opendous_usb_read(struct opendous_jtag *opendous_jtag)
Definition: opendous.c:769
static int opendous_get_status(void)
Definition: opendous.c:531
static void opendous_state_move(void)
Definition: opendous.c:407
#define JTAG_CMD_SET_SRST_TRST
Definition: opendous.c:90
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
Represents a driver for a debugging interface.
Definition: interface.h:184
int(* execute_queue)(void)
Execute queued commands.
Definition: interface.h:195
struct libusb_device_handle * usb_handle
Definition: opendous.c:126
uint8_t WRITE_EP
Definition: opendous.c:35
uint16_t PID[OPENDOUS_MAX_VIDS_PIDS]
Definition: opendous.c:33
const char * name
Definition: opendous.c:31
int BUFFERSIZE
Definition: opendous.c:37
uint8_t READ_EP
Definition: opendous.c:34
uint8_t CONTROL_TRANSFER
Definition: opendous.c:36
uint16_t VID[OPENDOUS_MAX_VIDS_PIDS]
Definition: opendous.c:32
int first
First bit position in tdo_buffer to read.
Definition: arm-jtag-ew.c:517
int length
Number of bits to read.
Definition: arm-jtag-ew.c:518
uint8_t * buffer
Location to store the result.
Definition: arm-jtag-ew.c:520
struct scan_command * command
Definition: arm-jtag-ew.c:519
The scan_command provide a means of encapsulating a set of scan_field_s structures that should be sca...
Definition: commands.h:35
#define NULL
Definition: usb.h:16
uint8_t cmd
Definition: vdebug.c:1
uint8_t state[4]
Definition: vdebug.c:21