OpenOCD
ti_icdi_usb.c
Go to the documentation of this file.
1 // SPDX-License-Identifier: GPL-2.0-or-later
2 
3 /***************************************************************************
4  * *
5  * Copyright (C) 2012 by Spencer Oliver *
6  * spen@spen-soft.co.uk *
7  ***************************************************************************/
8 
9 #ifdef HAVE_CONFIG_H
10 #include "config.h"
11 #endif
12 
13 /* project specific includes */
14 #include <helper/binarybuffer.h>
15 #include <jtag/adapter.h>
16 #include <jtag/interface.h>
17 #include <jtag/hla/hla_layout.h>
18 #include <jtag/hla/hla_transport.h>
19 #include <jtag/hla/hla_interface.h>
20 #include <target/target.h>
21 
22 #include <target/cortex_m.h>
23 
24 #include "libusb_helper.h"
25 
26 #define ICDI_WRITE_ENDPOINT 0x02
27 #define ICDI_READ_ENDPOINT 0x83
28 
29 #define ICDI_WRITE_TIMEOUT (LIBUSB_TIMEOUT_MS)
30 #define ICDI_READ_TIMEOUT (LIBUSB_TIMEOUT_MS)
31 #define ICDI_PACKET_SIZE 2048
32 
33 #define PACKET_START "$"
34 #define PACKET_END "#"
35 
37  struct libusb_device_handle *usb_dev;
38 
39  char *read_buffer;
40  char *write_buffer;
43  uint32_t max_rw_packet; /* max X packet (read/write memory) transfers */
44 };
45 
46 static int icdi_usb_read_mem(void *handle, uint32_t addr, uint32_t size,
47  uint32_t count, uint8_t *buffer);
48 static int icdi_usb_write_mem(void *handle, uint32_t addr, uint32_t size,
49  uint32_t count, const uint8_t *buffer);
50 
51 static int remote_escape_output(const char *buffer, int len, char *out_buf, int *out_len, int out_maxlen)
52 {
53  int input_index, output_index;
54 
55  output_index = 0;
56 
57  for (input_index = 0; input_index < len; input_index++) {
58 
59  char b = buffer[input_index];
60 
61  if (b == '$' || b == '#' || b == '}' || b == '*') {
62  /* These must be escaped. */
63  if (output_index + 2 > out_maxlen)
64  break;
65  out_buf[output_index++] = '}';
66  out_buf[output_index++] = b ^ 0x20;
67  } else {
68  if (output_index + 1 > out_maxlen)
69  break;
70  out_buf[output_index++] = b;
71  }
72  }
73 
74  *out_len = input_index;
75  return output_index;
76 }
77 
78 static int remote_unescape_input(const char *buffer, int len, char *out_buf, int out_maxlen)
79 {
80  int input_index, output_index;
81  int escaped;
82 
83  output_index = 0;
84  escaped = 0;
85 
86  for (input_index = 0; input_index < len; input_index++) {
87 
88  char b = buffer[input_index];
89 
90  if (output_index + 1 > out_maxlen)
91  LOG_ERROR("Received too much data from the target.");
92 
93  if (escaped) {
94  out_buf[output_index++] = b ^ 0x20;
95  escaped = 0;
96  } else if (b == '}')
97  escaped = 1;
98  else
99  out_buf[output_index++] = b;
100  }
101 
102  if (escaped)
103  LOG_ERROR("Unmatched escape character in target response.");
104 
105  return output_index;
106 }
107 
108 static int icdi_send_packet(void *handle, int len)
109 {
110  unsigned char cksum = 0;
111  struct icdi_usb_handle_s *h = handle;
112  int result, retry = 0;
113  int transferred = 0;
114 
115  assert(handle);
116 
117  /* check we have a large enough buffer for checksum "#00" */
118  if (len + 3 > h->max_packet) {
119  LOG_ERROR("packet buffer too small");
120  return ERROR_FAIL;
121  }
122 
123  /* calculate checksum - offset start of packet */
124  for (int i = 1; i < len; i++)
125  cksum += h->write_buffer[i];
126 
127  len += sprintf(&h->write_buffer[len], PACKET_END "%02x", cksum);
128 
129 #ifdef _DEBUG_USB_COMMS_
130  char buffer[50];
131  char ch = h->write_buffer[1];
132  if (ch == 'x' || ch == 'X')
133  LOG_DEBUG("writing packet: <binary>");
134  else {
135  memcpy(buffer, h->write_buffer, len >= 50 ? 50-1 : len);
136  buffer[len] = 0;
137  LOG_DEBUG("writing packet: %s", buffer);
138  }
139 #endif
140 
141  while (1) {
142 
143  result = libusb_bulk_transfer(h->usb_dev, ICDI_WRITE_ENDPOINT, (unsigned char *)h->write_buffer, len,
144  &transferred, ICDI_WRITE_TIMEOUT);
145  if (result != 0 || transferred != len) {
146  LOG_DEBUG("Error TX Data %d", result);
147  return ERROR_FAIL;
148  }
149 
150  /* check that the client got the message ok, or shall we resend */
151  result = libusb_bulk_transfer(h->usb_dev, ICDI_READ_ENDPOINT, (unsigned char *)h->read_buffer, h->max_packet,
152  &transferred, ICDI_READ_TIMEOUT);
153  if (result != 0 || transferred < 1) {
154  LOG_DEBUG("Error RX Data %d", result);
155  return ERROR_FAIL;
156  }
157 
158 #ifdef _DEBUG_USB_COMMS_
159  LOG_DEBUG("received reply: '%c' : count %d", h->read_buffer[0], transferred);
160 #endif
161 
162  if (h->read_buffer[0] == '-') {
163  LOG_DEBUG("Resending packet %d", ++retry);
164  } else {
165  if (h->read_buffer[0] != '+')
166  LOG_DEBUG("Unexpected Reply from ICDI: %c", h->read_buffer[0]);
167  break;
168  }
169 
170  if (retry == 3) {
171  LOG_DEBUG("maximum nack retries attempted");
172  return ERROR_FAIL;
173  }
174  }
175 
176  retry = 0;
177  h->read_count = transferred;
178 
179  while (1) {
180 
181  /* read reply from icdi */
182  result = libusb_bulk_transfer(h->usb_dev, ICDI_READ_ENDPOINT, (unsigned char *)h->read_buffer + h->read_count,
183  h->max_packet - h->read_count, &transferred, ICDI_READ_TIMEOUT);
184 
185 #ifdef _DEBUG_USB_COMMS_
186  LOG_DEBUG("received data: count %d", transferred);
187 #endif
188 
189  /* check for errors but retry for timeout */
190  if (result != 0) {
191 
192  if (result == LIBUSB_ERROR_TIMEOUT) {
193  LOG_DEBUG("Error RX timeout %d", result);
194  } else {
195  LOG_DEBUG("Error RX Data %d", result);
196  return ERROR_FAIL;
197  }
198  }
199 
200  h->read_count += transferred;
201 
202  /* we need to make sure we have a full packet, including checksum */
203  if (h->read_count > 5) {
204 
205  /* check that we have received an packet delimiter
206  * we do not validate the checksum
207  * reply should contain $...#AA - so we check for # */
208  if (h->read_buffer[h->read_count - 3] == '#')
209  return ERROR_OK;
210  }
211 
212  if (retry++ == 3) {
213  LOG_DEBUG("maximum data retries attempted");
214  break;
215  }
216  }
217 
218  return ERROR_FAIL;
219 }
220 
221 static int icdi_send_cmd(void *handle, const char *cmd)
222 {
223  struct icdi_usb_handle_s *h = handle;
224 
225  int cmd_len = snprintf(h->write_buffer, h->max_packet, PACKET_START "%s", cmd);
226  return icdi_send_packet(handle, cmd_len);
227 }
228 
229 static int icdi_send_remote_cmd(void *handle, const char *data)
230 {
231  struct icdi_usb_handle_s *h = handle;
232 
233  size_t cmd_len = sprintf(h->write_buffer, PACKET_START "qRcmd,");
234  cmd_len += hexify(h->write_buffer + cmd_len, (const uint8_t *)data,
235  strlen(data), h->max_packet - cmd_len);
236 
237  return icdi_send_packet(handle, cmd_len);
238 }
239 
240 static int icdi_get_cmd_result(void *handle)
241 {
242  struct icdi_usb_handle_s *h = handle;
243  int offset = 0;
244  char ch;
245 
246  assert(handle);
247 
248  do {
249  ch = h->read_buffer[offset++];
250  if (offset > h->read_count)
251  return ERROR_FAIL;
252  } while (ch != '$');
253 
254  if (memcmp("OK", h->read_buffer + offset, 2) == 0)
255  return ERROR_OK;
256 
257  if (h->read_buffer[offset] == 'E') {
258  /* get error code */
259  uint8_t result;
260  if (unhexify(&result, h->read_buffer + offset + 1, 1) != 1)
261  return ERROR_FAIL;
262  return result;
263  }
264 
265  /* for now we assume everything else is ok */
266  return ERROR_OK;
267 }
268 
269 static int icdi_usb_idcode(void *handle, uint32_t *idcode)
270 {
271  *idcode = 0;
272  return ERROR_OK;
273 }
274 
275 static int icdi_usb_write_debug_reg(void *handle, uint32_t addr, uint32_t val)
276 {
277  uint8_t buf[4];
278  /* REVISIT: There's no target pointer here so there's no way to use target_buffer_set_u32().
279  * I guess all supported chips are little-endian anyway. */
280  h_u32_to_le(buf, val);
281  return icdi_usb_write_mem(handle, addr, 4, 1, buf);
282 }
283 
284 static enum target_state icdi_usb_state(void *handle)
285 {
286  int result;
287  struct icdi_usb_handle_s *h = handle;
288  uint32_t dhcsr;
289  uint8_t buf[4];
290 
291  result = icdi_usb_read_mem(h, DCB_DHCSR, 4, 1, buf);
292  if (result != ERROR_OK)
293  return TARGET_UNKNOWN;
294 
295  /* REVISIT: There's no target pointer here so there's no way to use target_buffer_get_u32().
296  * I guess all supported chips are little-endian anyway. */
297  dhcsr = le_to_h_u32(buf);
298  if (dhcsr & S_HALT)
299  return TARGET_HALTED;
300 
301  return TARGET_RUNNING;
302 }
303 
304 static int icdi_usb_version(void *handle)
305 {
306  struct icdi_usb_handle_s *h = handle;
307 
308  char version[20];
309 
310  /* get info about icdi */
311  int result = icdi_send_remote_cmd(handle, "version");
312  if (result != ERROR_OK)
313  return result;
314 
315  if (h->read_count < 8) {
316  LOG_ERROR("Invalid Reply Received");
317  return ERROR_FAIL;
318  }
319 
320  /* convert reply */
321  if (unhexify((uint8_t *)version, h->read_buffer + 2, 4) != 4) {
322  LOG_WARNING("unable to get ICDI version");
323  return ERROR_OK;
324  }
325 
326  /* null terminate and print info */
327  version[4] = 0;
328 
329  LOG_INFO("ICDI Firmware version: %s", version);
330 
331  return ERROR_OK;
332 }
333 
334 static int icdi_usb_query(void *handle)
335 {
336  int result;
337 
338  struct icdi_usb_handle_s *h = handle;
339 
340  result = icdi_send_cmd(handle, "qSupported");
341  if (result != ERROR_OK)
342  return result;
343 
344  /* check result */
345  result = icdi_get_cmd_result(handle);
346  if (result != ERROR_OK) {
347  LOG_ERROR("query supported failed: 0x%x", result);
348  return ERROR_FAIL;
349  }
350 
351  /* from this we can get the max packet supported */
352 
353  /* query packet buffer size */
354  char *offset = strstr(h->read_buffer, "PacketSize");
355  if (offset) {
356  char *separator;
357  int max_packet;
358 
359  max_packet = strtol(offset + 11, &separator, 16);
360  if (!max_packet)
361  LOG_ERROR("invalid max packet, using defaults");
362  else
363  h->max_packet = max_packet;
364  LOG_DEBUG("max packet supported : %i bytes", h->max_packet);
365  }
366 
367 
368  /* if required re allocate packet buffer */
369  if (h->max_packet != ICDI_PACKET_SIZE) {
370  h->read_buffer = realloc(h->read_buffer, h->max_packet);
371  h->write_buffer = realloc(h->write_buffer, h->max_packet);
372  if (h->read_buffer == 0 || h->write_buffer == 0) {
373  LOG_ERROR("unable to reallocate memory");
374  return ERROR_FAIL;
375  }
376  }
377 
378  /* set extended mode */
379  result = icdi_send_cmd(handle, "!");
380  if (result != ERROR_OK)
381  return result;
382 
383  /* check result */
384  result = icdi_get_cmd_result(handle);
385  if (result != ERROR_OK) {
386  LOG_ERROR("unable to enable extended mode: 0x%x", result);
387  return ERROR_FAIL;
388  }
389 
390  return ERROR_OK;
391 }
392 
393 static int icdi_usb_reset(void *handle)
394 {
395  /* we do this in hla_target.c */
396  return ERROR_OK;
397 }
398 
399 static int icdi_usb_assert_srst(void *handle, int srst)
400 {
401  /* TODO not supported yet */
402  return ERROR_COMMAND_NOTFOUND;
403 }
404 
405 static int icdi_usb_run(void *handle)
406 {
407  int result;
408 
409  /* resume target at current address */
410  result = icdi_send_cmd(handle, "c");
411  if (result != ERROR_OK)
412  return result;
413 
414  /* check result */
415  result = icdi_get_cmd_result(handle);
416  if (result != ERROR_OK) {
417  LOG_ERROR("continue failed: 0x%x", result);
418  return ERROR_FAIL;
419  }
420 
421  return result;
422 }
423 
424 static int icdi_usb_halt(void *handle)
425 {
426  int result;
427 
428  /* this query halts the target ?? */
429  result = icdi_send_cmd(handle, "?");
430  if (result != ERROR_OK)
431  return result;
432 
433  /* check result */
434  result = icdi_get_cmd_result(handle);
435  if (result != ERROR_OK) {
436  LOG_ERROR("halt failed: 0x%x", result);
437  return ERROR_FAIL;
438  }
439 
440  return result;
441 }
442 
443 static int icdi_usb_step(void *handle)
444 {
445  int result;
446 
447  /* step target at current address */
448  result = icdi_send_cmd(handle, "s");
449  if (result != ERROR_OK)
450  return result;
451 
452  /* check result */
453  result = icdi_get_cmd_result(handle);
454  if (result != ERROR_OK) {
455  LOG_ERROR("step failed: 0x%x", result);
456  return ERROR_FAIL;
457  }
458 
459  return result;
460 }
461 
462 static int icdi_usb_read_regs(void *handle)
463 {
464  /* currently unsupported */
465  return ERROR_OK;
466 }
467 
468 static int icdi_usb_read_reg(void *handle, unsigned int regsel, uint32_t *val)
469 {
470  int result;
471  struct icdi_usb_handle_s *h = handle;
472  char cmd[10];
473 
474  snprintf(cmd, sizeof(cmd), "p%x", regsel);
475  result = icdi_send_cmd(handle, cmd);
476  if (result != ERROR_OK)
477  return result;
478 
479  /* check result */
480  result = icdi_get_cmd_result(handle);
481  if (result != ERROR_OK) {
482  LOG_ERROR("register read failed: 0x%x", result);
483  return ERROR_FAIL;
484  }
485 
486  /* convert result */
487  uint8_t buf[4];
488  if (unhexify(buf, h->read_buffer + 2, 4) != 4) {
489  LOG_ERROR("failed to convert result");
490  return ERROR_FAIL;
491  }
492  *val = le_to_h_u32(buf);
493 
494  return result;
495 }
496 
497 static int icdi_usb_write_reg(void *handle, unsigned int regsel, uint32_t val)
498 {
499  int result;
500  char cmd[20];
501  uint8_t buf[4];
502  h_u32_to_le(buf, val);
503 
504  int cmd_len = snprintf(cmd, sizeof(cmd), "P%x=", regsel);
505  hexify(cmd + cmd_len, buf, 4, sizeof(cmd));
506 
507  result = icdi_send_cmd(handle, cmd);
508  if (result != ERROR_OK)
509  return result;
510 
511  /* check result */
512  result = icdi_get_cmd_result(handle);
513  if (result != ERROR_OK) {
514  LOG_ERROR("register write failed: 0x%x", result);
515  return ERROR_FAIL;
516  }
517 
518  return result;
519 }
520 
521 static int icdi_usb_read_mem_int(void *handle, uint32_t addr, uint32_t len, uint8_t *buffer)
522 {
523  int result;
524  struct icdi_usb_handle_s *h = handle;
525  char cmd[20];
526 
527  snprintf(cmd, sizeof(cmd), "x%" PRIx32 ",%" PRIx32, addr, len);
528  result = icdi_send_cmd(handle, cmd);
529  if (result != ERROR_OK)
530  return result;
531 
532  /* check result */
533  result = icdi_get_cmd_result(handle);
534  if (result != ERROR_OK) {
535  LOG_ERROR("memory read failed: 0x%x", result);
536  return ERROR_FAIL;
537  }
538 
539  /* unescape input */
540  int read_len = remote_unescape_input(h->read_buffer + 5, h->read_count - 8, (char *)buffer, len);
541  if (read_len != (int)len) {
542  LOG_ERROR("read more bytes than expected: actual 0x%x expected 0x%" PRIx32, read_len, len);
543  return ERROR_FAIL;
544  }
545 
546  return ERROR_OK;
547 }
548 
549 static int icdi_usb_write_mem_int(void *handle, uint32_t addr, uint32_t len, const uint8_t *buffer)
550 {
551  int result;
552  struct icdi_usb_handle_s *h = handle;
553 
554  size_t cmd_len = snprintf(h->write_buffer, h->max_packet, PACKET_START "X%" PRIx32 ",%" PRIx32 ":", addr, len);
555 
556  int out_len;
557  cmd_len += remote_escape_output((const char *)buffer, len, h->write_buffer + cmd_len,
558  &out_len, h->max_packet - cmd_len);
559 
560  if (out_len < (int)len) {
561  /* for now issue a error as we have no way of allocating a larger buffer */
562  LOG_ERROR("memory buffer too small: requires 0x%x actual 0x%" PRIx32, out_len, len);
563  return ERROR_FAIL;
564  }
565 
566  result = icdi_send_packet(handle, cmd_len);
567  if (result != ERROR_OK)
568  return result;
569 
570  /* check result */
571  result = icdi_get_cmd_result(handle);
572  if (result != ERROR_OK) {
573  LOG_ERROR("memory write failed: 0x%x", result);
574  return ERROR_FAIL;
575  }
576 
577  return ERROR_OK;
578 }
579 
580 static int icdi_usb_read_mem(void *handle, uint32_t addr, uint32_t size,
581  uint32_t count, uint8_t *buffer)
582 {
583  int retval = ERROR_OK;
584  struct icdi_usb_handle_s *h = handle;
585  uint32_t bytes_remaining;
586 
587  /* calculate byte count */
588  count *= size;
589 
590  while (count) {
591 
592  bytes_remaining = h->max_rw_packet;
593  if (count < bytes_remaining)
594  bytes_remaining = count;
595 
596  retval = icdi_usb_read_mem_int(handle, addr, bytes_remaining, buffer);
597  if (retval != ERROR_OK)
598  return retval;
599 
600  buffer += bytes_remaining;
601  addr += bytes_remaining;
602  count -= bytes_remaining;
603  }
604 
605  return retval;
606 }
607 
608 static int icdi_usb_write_mem(void *handle, uint32_t addr, uint32_t size,
609  uint32_t count, const uint8_t *buffer)
610 {
611  int retval = ERROR_OK;
612  struct icdi_usb_handle_s *h = handle;
613  uint32_t bytes_remaining;
614 
615  /* calculate byte count */
616  count *= size;
617 
618  while (count) {
619 
620  bytes_remaining = h->max_rw_packet;
621  if (count < bytes_remaining)
622  bytes_remaining = count;
623 
624  retval = icdi_usb_write_mem_int(handle, addr, bytes_remaining, buffer);
625  if (retval != ERROR_OK)
626  return retval;
627 
628  buffer += bytes_remaining;
629  addr += bytes_remaining;
630  count -= bytes_remaining;
631  }
632 
633  return retval;
634 }
635 
636 static int icdi_usb_override_target(const char *targetname)
637 {
638  return !strcmp(targetname, "cortex_m");
639 }
640 
641 static int icdi_usb_close(void *handle)
642 {
643  struct icdi_usb_handle_s *h = handle;
644 
645  if (!h)
646  return ERROR_OK;
647 
648  if (h->usb_dev)
650 
651  free(h->read_buffer);
652  free(h->write_buffer);
653  free(handle);
654  return ERROR_OK;
655 }
656 
657 static int icdi_usb_open(struct hl_interface_param_s *param, void **fd)
658 {
659  /* TODO: Convert remaining libusb_ calls to jtag_libusb_ */
660  int retval;
661  struct icdi_usb_handle_s *h;
662 
663  LOG_DEBUG("icdi_usb_open");
664 
665  h = calloc(1, sizeof(struct icdi_usb_handle_s));
666 
667  if (h == 0) {
668  LOG_ERROR("unable to allocate memory");
669  return ERROR_FAIL;
670  }
671 
672  for (uint8_t i = 0; param->vid[i] && param->pid[i]; ++i)
673  LOG_DEBUG("transport: %d vid: 0x%04x pid: 0x%04x serial: %s", param->transport,
675 
676  /* TI (Stellaris) ICDI provides its serial number in the USB descriptor;
677  no need to provide a callback here. */
679 
680  if (!h->usb_dev) {
681  LOG_ERROR("open failed");
682  goto error_open;
683  }
684 
685  if (libusb_claim_interface(h->usb_dev, 2)) {
686  LOG_DEBUG("claim interface failed");
687  goto error_open;
688  }
689 
690  /* check if mode is supported */
691  retval = ERROR_OK;
692 
693  switch (param->transport) {
694 #if 0
695  /* TODO place holder as swd is not currently supported */
696  case HL_TRANSPORT_SWD:
697 #endif
698  case HL_TRANSPORT_JTAG:
699  break;
700  default:
701  retval = ERROR_FAIL;
702  break;
703  }
704 
705  if (retval != ERROR_OK) {
706  LOG_ERROR("mode (transport) not supported by device");
707  goto error_open;
708  }
709 
710  /* allocate buffer */
711  h->read_buffer = malloc(ICDI_PACKET_SIZE);
712  h->write_buffer = malloc(ICDI_PACKET_SIZE);
714 
715  if (h->read_buffer == 0 || h->write_buffer == 0) {
716  LOG_DEBUG("malloc failed");
717  goto error_open;
718  }
719 
720  /* query icdi version etc */
721  retval = icdi_usb_version(h);
722  if (retval != ERROR_OK)
723  goto error_open;
724 
725  /* query icdi support */
726  retval = icdi_usb_query(h);
727  if (retval != ERROR_OK)
728  goto error_open;
729 
730  *fd = h;
731 
732  /* set the max target read/write buffer in bytes
733  * as we are using gdb binary packets to transfer memory we have to
734  * reserve half the buffer for any possible escape chars plus
735  * at least 64 bytes for the gdb packet header */
736  h->max_rw_packet = (((h->max_packet - 64) / 4) * 4) / 2;
737 
738  return ERROR_OK;
739 
740 error_open:
741  icdi_usb_close(h);
742 
743  return ERROR_FAIL;
744 }
745 
747  .open = icdi_usb_open,
748  .close = icdi_usb_close,
749  .idcode = icdi_usb_idcode,
750  .state = icdi_usb_state,
751  .reset = icdi_usb_reset,
752  .assert_srst = icdi_usb_assert_srst,
753  .run = icdi_usb_run,
754  .halt = icdi_usb_halt,
755  .step = icdi_usb_step,
756  .read_regs = icdi_usb_read_regs,
757  .read_reg = icdi_usb_read_reg,
758  .write_reg = icdi_usb_write_reg,
759  .read_mem = icdi_usb_read_mem,
760  .write_mem = icdi_usb_write_mem,
761  .write_debug_reg = icdi_usb_write_debug_reg,
762  .override_target = icdi_usb_override_target,
763  .custom_command = icdi_send_remote_cmd,
764 };
const char * adapter_get_required_serial(void)
Retrieves the serial number set with command 'adapter serial'.
Definition: adapter.c:299
static struct aice_port_param_s param
size_t hexify(char *hex, const uint8_t *bin, size_t count, size_t length)
Convert binary data into a string of hexadecimal pairs.
Definition: binarybuffer.c:392
size_t unhexify(uint8_t *bin, const char *hex, size_t count)
Convert a string of hexadecimal pairs into its binary representation.
Definition: binarybuffer.c:354
Support functions to access arbitrary bits in a byte array.
#define ERROR_COMMAND_NOTFOUND
Definition: command.h:386
#define S_HALT
Definition: cortex_m.h:120
#define DCB_DHCSR
Definition: cortex_m.h:65
@ HL_TRANSPORT_SWD
Definition: hla_transport.h:16
@ HL_TRANSPORT_JTAG
Definition: hla_transport.h:17
void jtag_libusb_close(struct libusb_device_handle *dev)
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_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
uint32_t addr
Definition: nuttx.c:65
size_t size
Size of the control block search area.
Definition: rtt/rtt.c:30
uint16_t vid
Definition: aice_port.h:99
int(* open)(struct hl_interface_param_s *param, void **handle)
Definition: hla_layout.h:29
struct libusb_device_handle * usb_dev
Definition: ti_icdi_usb.c:37
uint32_t max_rw_packet
Definition: ti_icdi_usb.c:43
target_state
Definition: target.h:52
@ TARGET_UNKNOWN
Definition: target.h:53
@ TARGET_HALTED
Definition: target.h:55
@ TARGET_RUNNING
Definition: target.h:54
#define ICDI_WRITE_TIMEOUT
Definition: ti_icdi_usb.c:29
static int remote_unescape_input(const char *buffer, int len, char *out_buf, int out_maxlen)
Definition: ti_icdi_usb.c:78
static int icdi_send_remote_cmd(void *handle, const char *data)
Definition: ti_icdi_usb.c:229
#define ICDI_PACKET_SIZE
Definition: ti_icdi_usb.c:31
static int icdi_usb_read_mem(void *handle, uint32_t addr, uint32_t size, uint32_t count, uint8_t *buffer)
Definition: ti_icdi_usb.c:580
static int icdi_usb_override_target(const char *targetname)
Definition: ti_icdi_usb.c:636
static enum target_state icdi_usb_state(void *handle)
Definition: ti_icdi_usb.c:284
static int icdi_usb_open(struct hl_interface_param_s *param, void **fd)
Definition: ti_icdi_usb.c:657
static int icdi_usb_assert_srst(void *handle, int srst)
Definition: ti_icdi_usb.c:399
#define ICDI_WRITE_ENDPOINT
Definition: ti_icdi_usb.c:26
static int icdi_usb_query(void *handle)
Definition: ti_icdi_usb.c:334
static int icdi_get_cmd_result(void *handle)
Definition: ti_icdi_usb.c:240
struct hl_layout_api_s icdi_usb_layout_api
Definition: ti_icdi_usb.c:746
static int icdi_usb_step(void *handle)
Definition: ti_icdi_usb.c:443
#define ICDI_READ_TIMEOUT
Definition: ti_icdi_usb.c:30
#define ICDI_READ_ENDPOINT
Definition: ti_icdi_usb.c:27
static int icdi_usb_read_mem_int(void *handle, uint32_t addr, uint32_t len, uint8_t *buffer)
Definition: ti_icdi_usb.c:521
static int icdi_usb_idcode(void *handle, uint32_t *idcode)
Definition: ti_icdi_usb.c:269
static int icdi_send_cmd(void *handle, const char *cmd)
Definition: ti_icdi_usb.c:221
static int remote_escape_output(const char *buffer, int len, char *out_buf, int *out_len, int out_maxlen)
Definition: ti_icdi_usb.c:51
static int icdi_usb_halt(void *handle)
Definition: ti_icdi_usb.c:424
static int icdi_usb_write_mem(void *handle, uint32_t addr, uint32_t size, uint32_t count, const uint8_t *buffer)
Definition: ti_icdi_usb.c:608
#define PACKET_END
Definition: ti_icdi_usb.c:34
static int icdi_usb_close(void *handle)
Definition: ti_icdi_usb.c:641
static int icdi_usb_write_reg(void *handle, unsigned int regsel, uint32_t val)
Definition: ti_icdi_usb.c:497
#define PACKET_START
Definition: ti_icdi_usb.c:33
static int icdi_usb_version(void *handle)
Definition: ti_icdi_usb.c:304
static int icdi_send_packet(void *handle, int len)
Definition: ti_icdi_usb.c:108
static int icdi_usb_write_mem_int(void *handle, uint32_t addr, uint32_t len, const uint8_t *buffer)
Definition: ti_icdi_usb.c:549
static int icdi_usb_read_regs(void *handle)
Definition: ti_icdi_usb.c:462
static int icdi_usb_run(void *handle)
Definition: ti_icdi_usb.c:405
static int icdi_usb_reset(void *handle)
Definition: ti_icdi_usb.c:393
static int icdi_usb_write_debug_reg(void *handle, uint32_t addr, uint32_t val)
Definition: ti_icdi_usb.c:275
static int icdi_usb_read_reg(void *handle, unsigned int regsel, uint32_t *val)
Definition: ti_icdi_usb.c:468
static void h_u32_to_le(uint8_t *buf, uint32_t val)
Definition: types.h:178
static uint32_t le_to_h_u32(const uint8_t *buf)
Definition: types.h:112
#define NULL
Definition: usb.h:16
uint8_t cmd
Definition: vdebug.c:1
uint8_t offset[4]
Definition: vdebug.c:9
uint8_t count[4]
Definition: vdebug.c:22