OpenOCD
mpsse.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 
8 #ifdef HAVE_CONFIG_H
9 #include "config.h"
10 #endif
11 
12 #include "mpsse.h"
13 #include "helper/log.h"
14 #include "helper/replacements.h"
15 #include "helper/time_support.h"
16 #include "libusb_helper.h"
17 #include <libusb.h>
18 
19 /* Compatibility define for older libusb-1.0 */
20 #ifndef LIBUSB_CALL
21 #define LIBUSB_CALL
22 #endif
23 
24 #define DEBUG_PRINT_BUF(buf, len) \
25  do { \
26  if (LOG_LEVEL_IS(LOG_LVL_DEBUG_IO)) { \
27  char buf_string[32 * 3 + 1]; \
28  int buf_string_pos = 0; \
29  for (int i = 0; i < len; i++) { \
30  buf_string_pos += sprintf(buf_string + buf_string_pos, " %02x", buf[i]); \
31  if (i % 32 == 32 - 1) { \
32  LOG_DEBUG_IO("%s", buf_string); \
33  buf_string_pos = 0; \
34  } \
35  } \
36  if (buf_string_pos > 0) \
37  LOG_DEBUG_IO("%s", buf_string);\
38  } \
39  } while (0)
40 
41 #define FTDI_DEVICE_OUT_REQTYPE (LIBUSB_REQUEST_TYPE_VENDOR | LIBUSB_RECIPIENT_DEVICE)
42 #define FTDI_DEVICE_IN_REQTYPE (0x80 | LIBUSB_REQUEST_TYPE_VENDOR | LIBUSB_RECIPIENT_DEVICE)
43 
44 #define BITMODE_MPSSE 0x02
45 
46 #define SIO_RESET_REQUEST 0x00
47 #define SIO_SET_LATENCY_TIMER_REQUEST 0x09
48 #define SIO_GET_LATENCY_TIMER_REQUEST 0x0A
49 #define SIO_SET_BITMODE_REQUEST 0x0B
50 
51 #define SIO_RESET_SIO 0
52 #define SIO_RESET_PURGE_RX 1
53 #define SIO_RESET_PURGE_TX 2
54 
55 struct mpsse_ctx {
56  struct libusb_context *usb_ctx;
57  struct libusb_device_handle *usb_dev;
58  unsigned int usb_write_timeout;
59  unsigned int usb_read_timeout;
60  uint8_t in_ep;
61  uint8_t out_ep;
62  uint16_t max_packet_size;
63  uint16_t index;
64  uint8_t interface;
65  enum ftdi_chip_type type;
66  uint8_t *write_buffer;
67  unsigned write_size;
68  unsigned write_count;
69  uint8_t *read_buffer;
70  unsigned read_size;
71  unsigned read_count;
72  uint8_t *read_chunk;
73  unsigned read_chunk_size;
75  int retval;
76 };
77 
78 /* Returns true if the string descriptor indexed by str_index in device matches string */
79 static bool string_descriptor_equal(struct libusb_device_handle *device, uint8_t str_index,
80  const char *string)
81 {
82  int retval;
83  char desc_string[256]; /* Max size of string descriptor */
84  retval = libusb_get_string_descriptor_ascii(device, str_index, (unsigned char *)desc_string,
85  sizeof(desc_string));
86  if (retval < 0) {
87  LOG_ERROR("libusb_get_string_descriptor_ascii() failed with %s", libusb_error_name(retval));
88  return false;
89  }
90  return strncmp(string, desc_string, sizeof(desc_string)) == 0;
91 }
92 
93 static bool device_location_equal(struct libusb_device *device, const char *location)
94 {
95  bool result = false;
96 #ifdef HAVE_LIBUSB_GET_PORT_NUMBERS
97  char *loc = strdup(location);
98  uint8_t port_path[7];
99  int path_step, path_len;
100  uint8_t dev_bus = libusb_get_bus_number(device);
101  char *ptr;
102 
103  path_len = libusb_get_port_numbers(device, port_path, 7);
104  if (path_len == LIBUSB_ERROR_OVERFLOW) {
105  LOG_ERROR("cannot determine path to usb device! (more than 7 ports in path)");
106  goto done;
107  }
108 
109  LOG_DEBUG("device path has %i steps", path_len);
110 
111  ptr = strtok(loc, "-:");
112  if (!ptr) {
113  LOG_DEBUG("no ':' in path");
114  goto done;
115  }
116  if (atoi(ptr) != dev_bus) {
117  LOG_DEBUG("bus mismatch");
118  goto done;
119  }
120 
121  path_step = 0;
122  while (path_step < 7) {
123  ptr = strtok(NULL, ".,");
124  if (!ptr) {
125  LOG_DEBUG("no more tokens in path at step %i", path_step);
126  break;
127  }
128 
129  if (path_step < path_len
130  && atoi(ptr) != port_path[path_step]) {
131  LOG_DEBUG("path mismatch at step %i", path_step);
132  break;
133  }
134 
135  path_step++;
136  };
137 
138  /* walked the full path, all elements match */
139  if (path_step == path_len)
140  result = true;
141 
142  done:
143  free(loc);
144 #endif
145  return result;
146 }
147 
148 /* Helper to open a libusb device that matches vid, pid, product string and/or serial string.
149  * Set any field to 0 as a wildcard. If the device is found true is returned, with ctx containing
150  * the already opened handle. ctx->interface must be set to the desired interface (channel) number
151  * prior to calling this function. */
152 static bool open_matching_device(struct mpsse_ctx *ctx, const uint16_t vids[], const uint16_t pids[],
153  const char *product, const char *serial, const char *location)
154 {
155  struct libusb_device **list;
156  struct libusb_device_descriptor desc;
157  struct libusb_config_descriptor *config0;
158  int err;
159  bool found = false;
160  ssize_t cnt = libusb_get_device_list(ctx->usb_ctx, &list);
161  if (cnt < 0)
162  LOG_ERROR("libusb_get_device_list() failed with %s", libusb_error_name(cnt));
163 
164  for (ssize_t i = 0; i < cnt; i++) {
165  struct libusb_device *device = list[i];
166 
167  err = libusb_get_device_descriptor(device, &desc);
168  if (err != LIBUSB_SUCCESS) {
169  LOG_ERROR("libusb_get_device_descriptor() failed with %s", libusb_error_name(err));
170  continue;
171  }
172 
173  if (!jtag_libusb_match_ids(&desc, vids, pids))
174  continue;
175 
176  err = libusb_open(device, &ctx->usb_dev);
177  if (err != LIBUSB_SUCCESS) {
178  LOG_ERROR("libusb_open() failed with %s",
179  libusb_error_name(err));
180  continue;
181  }
182 
183  if (location && !device_location_equal(device, location)) {
184  libusb_close(ctx->usb_dev);
185  continue;
186  }
187 
188  if (product && !string_descriptor_equal(ctx->usb_dev, desc.iProduct, product)) {
189  libusb_close(ctx->usb_dev);
190  continue;
191  }
192 
193  if (serial && !string_descriptor_equal(ctx->usb_dev, desc.iSerialNumber, serial)) {
194  libusb_close(ctx->usb_dev);
195  continue;
196  }
197 
198  found = true;
199  break;
200  }
201 
202  libusb_free_device_list(list, 1);
203 
204  if (!found) {
205  /* The caller reports detailed error desc */
206  return false;
207  }
208 
209  err = libusb_get_config_descriptor(libusb_get_device(ctx->usb_dev), 0, &config0);
210  if (err != LIBUSB_SUCCESS) {
211  LOG_ERROR("libusb_get_config_descriptor() failed with %s", libusb_error_name(err));
212  libusb_close(ctx->usb_dev);
213  return false;
214  }
215 
216  /* Make sure the first configuration is selected */
217  int cfg;
218  err = libusb_get_configuration(ctx->usb_dev, &cfg);
219  if (err != LIBUSB_SUCCESS) {
220  LOG_ERROR("libusb_get_configuration() failed with %s", libusb_error_name(err));
221  goto error;
222  }
223 
224  if (desc.bNumConfigurations > 0 && cfg != config0->bConfigurationValue) {
225  err = libusb_set_configuration(ctx->usb_dev, config0->bConfigurationValue);
226  if (err != LIBUSB_SUCCESS) {
227  LOG_ERROR("libusb_set_configuration() failed with %s", libusb_error_name(err));
228  goto error;
229  }
230  }
231 
232  /* Try to detach ftdi_sio kernel module */
233  err = libusb_detach_kernel_driver(ctx->usb_dev, ctx->interface);
234  if (err != LIBUSB_SUCCESS && err != LIBUSB_ERROR_NOT_FOUND
235  && err != LIBUSB_ERROR_NOT_SUPPORTED) {
236  LOG_WARNING("libusb_detach_kernel_driver() failed with %s, trying to continue anyway",
237  libusb_error_name(err));
238  }
239 
240  err = libusb_claim_interface(ctx->usb_dev, ctx->interface);
241  if (err != LIBUSB_SUCCESS) {
242  LOG_ERROR("libusb_claim_interface() failed with %s", libusb_error_name(err));
243  goto error;
244  }
245 
246  /* Reset FTDI device */
247  err = libusb_control_transfer(ctx->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
249  ctx->index, NULL, 0, ctx->usb_write_timeout);
250  if (err < 0) {
251  LOG_ERROR("failed to reset FTDI device: %s", libusb_error_name(err));
252  goto error;
253  }
254 
255  switch (desc.bcdDevice) {
256  case 0x500:
257  ctx->type = TYPE_FT2232C;
258  break;
259  case 0x700:
260  ctx->type = TYPE_FT2232H;
261  break;
262  case 0x800:
263  ctx->type = TYPE_FT4232H;
264  break;
265  case 0x900:
266  ctx->type = TYPE_FT232H;
267  break;
268  case 0x2800:
269  ctx->type = TYPE_FT2233HP;
270  break;
271  case 0x2900:
272  ctx->type = TYPE_FT4233HP;
273  break;
274  case 0x3000:
275  ctx->type = TYPE_FT2232HP;
276  break;
277  case 0x3100:
278  ctx->type = TYPE_FT4232HP;
279  break;
280  case 0x3200:
281  ctx->type = TYPE_FT233HP;
282  break;
283  case 0x3300:
284  ctx->type = TYPE_FT232HP;
285  break;
286  default:
287  LOG_ERROR("unsupported FTDI chip type: 0x%04x", desc.bcdDevice);
288  goto error;
289  }
290 
291  /* Determine maximum packet size and endpoint addresses */
292  if (!(desc.bNumConfigurations > 0 && ctx->interface < config0->bNumInterfaces
293  && config0->interface[ctx->interface].num_altsetting > 0))
294  goto desc_error;
295 
296  const struct libusb_interface_descriptor *descriptor;
297  descriptor = &config0->interface[ctx->interface].altsetting[0];
298  if (descriptor->bNumEndpoints != 2)
299  goto desc_error;
300 
301  ctx->in_ep = 0;
302  ctx->out_ep = 0;
303  for (int i = 0; i < descriptor->bNumEndpoints; i++) {
304  if (descriptor->endpoint[i].bEndpointAddress & 0x80) {
305  ctx->in_ep = descriptor->endpoint[i].bEndpointAddress;
306  ctx->max_packet_size =
307  descriptor->endpoint[i].wMaxPacketSize;
308  } else {
309  ctx->out_ep = descriptor->endpoint[i].bEndpointAddress;
310  }
311  }
312 
313  if (ctx->in_ep == 0 || ctx->out_ep == 0)
314  goto desc_error;
315 
316  libusb_free_config_descriptor(config0);
317  return true;
318 
319 desc_error:
320  LOG_ERROR("unrecognized USB device descriptor");
321 error:
322  libusb_free_config_descriptor(config0);
323  libusb_close(ctx->usb_dev);
324  return false;
325 }
326 
327 struct mpsse_ctx *mpsse_open(const uint16_t vids[], const uint16_t pids[], const char *description,
328  const char *serial, const char *location, int channel)
329 {
330  struct mpsse_ctx *ctx = calloc(1, sizeof(*ctx));
331  int err;
332 
333  if (!ctx)
334  return NULL;
335 
337  ctx->read_chunk_size = 16384;
338  ctx->read_size = 16384;
339  ctx->write_size = 16384;
340  ctx->read_chunk = malloc(ctx->read_chunk_size);
341  ctx->read_buffer = malloc(ctx->read_size);
342 
343  /* Use calloc to make valgrind happy: buffer_write() sets payload
344  * on bit basis, so some bits can be left uninitialized in write_buffer.
345  * Although this is perfectly ok with MPSSE, valgrind reports
346  * Syscall param ioctl(USBDEVFS_SUBMITURB).buffer points to uninitialised byte(s) */
347  ctx->write_buffer = calloc(1, ctx->write_size);
348 
349  if (!ctx->read_chunk || !ctx->read_buffer || !ctx->write_buffer)
350  goto error;
351 
352  ctx->interface = channel;
353  ctx->index = channel + 1;
354  ctx->usb_read_timeout = 5000;
355  ctx->usb_write_timeout = 5000;
356 
357  err = libusb_init(&ctx->usb_ctx);
358  if (err != LIBUSB_SUCCESS) {
359  LOG_ERROR("libusb_init() failed with %s", libusb_error_name(err));
360  goto error;
361  }
362 
363  if (!open_matching_device(ctx, vids, pids, description, serial, location)) {
364  LOG_ERROR("unable to open ftdi device with description '%s', "
365  "serial '%s' at bus location '%s'",
366  description ? description : "*",
367  serial ? serial : "*",
368  location ? location : "*");
369  ctx->usb_dev = NULL;
370  goto error;
371  }
372 
373  err = libusb_control_transfer(ctx->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
375  ctx->usb_write_timeout);
376  if (err < 0) {
377  LOG_ERROR("unable to set latency timer: %s", libusb_error_name(err));
378  goto error;
379  }
380 
381  err = libusb_control_transfer(ctx->usb_dev,
384  0x0b | (BITMODE_MPSSE << 8),
385  ctx->index,
386  NULL,
387  0,
388  ctx->usb_write_timeout);
389  if (err < 0) {
390  LOG_ERROR("unable to set MPSSE bitmode: %s", libusb_error_name(err));
391  goto error;
392  }
393 
394  mpsse_purge(ctx);
395 
396  return ctx;
397 error:
398  mpsse_close(ctx);
399  return NULL;
400 }
401 
402 void mpsse_close(struct mpsse_ctx *ctx)
403 {
404  if (ctx->usb_dev)
405  libusb_close(ctx->usb_dev);
406  if (ctx->usb_ctx)
407  libusb_exit(ctx->usb_ctx);
409 
410  free(ctx->write_buffer);
411  free(ctx->read_buffer);
412  free(ctx->read_chunk);
413  free(ctx);
414 }
415 
417 {
418  return ctx->type != TYPE_FT2232C;
419 }
420 
421 void mpsse_purge(struct mpsse_ctx *ctx)
422 {
423  int err;
424  LOG_DEBUG("-");
425  ctx->write_count = 0;
426  ctx->read_count = 0;
427  ctx->retval = ERROR_OK;
429  err = libusb_control_transfer(ctx->usb_dev, FTDI_DEVICE_OUT_REQTYPE, SIO_RESET_REQUEST,
431  if (err < 0) {
432  LOG_ERROR("unable to purge ftdi rx buffers: %s", libusb_error_name(err));
433  return;
434  }
435 
436  err = libusb_control_transfer(ctx->usb_dev, FTDI_DEVICE_OUT_REQTYPE, SIO_RESET_REQUEST,
438  if (err < 0) {
439  LOG_ERROR("unable to purge ftdi tx buffers: %s", libusb_error_name(err));
440  return;
441  }
442 }
443 
444 static unsigned buffer_write_space(struct mpsse_ctx *ctx)
445 {
446  /* Reserve one byte for SEND_IMMEDIATE */
447  return ctx->write_size - ctx->write_count - 1;
448 }
449 
450 static unsigned buffer_read_space(struct mpsse_ctx *ctx)
451 {
452  return ctx->read_size - ctx->read_count;
453 }
454 
455 static void buffer_write_byte(struct mpsse_ctx *ctx, uint8_t data)
456 {
457  LOG_DEBUG_IO("%02x", data);
458  assert(ctx->write_count < ctx->write_size);
459  ctx->write_buffer[ctx->write_count++] = data;
460 }
461 
462 static unsigned buffer_write(struct mpsse_ctx *ctx, const uint8_t *out, unsigned out_offset,
463  unsigned bit_count)
464 {
465  LOG_DEBUG_IO("%d bits", bit_count);
466  assert(ctx->write_count + DIV_ROUND_UP(bit_count, 8) <= ctx->write_size);
467  bit_copy(ctx->write_buffer + ctx->write_count, 0, out, out_offset, bit_count);
468  ctx->write_count += DIV_ROUND_UP(bit_count, 8);
469  return bit_count;
470 }
471 
472 static unsigned buffer_add_read(struct mpsse_ctx *ctx, uint8_t *in, unsigned in_offset,
473  unsigned bit_count, unsigned offset)
474 {
475  LOG_DEBUG_IO("%d bits, offset %d", bit_count, offset);
476  assert(ctx->read_count + DIV_ROUND_UP(bit_count, 8) <= ctx->read_size);
477  bit_copy_queued(&ctx->read_queue, in, in_offset, ctx->read_buffer + ctx->read_count, offset,
478  bit_count);
479  ctx->read_count += DIV_ROUND_UP(bit_count, 8);
480  return bit_count;
481 }
482 
483 void mpsse_clock_data_out(struct mpsse_ctx *ctx, const uint8_t *out, unsigned out_offset,
484  unsigned length, uint8_t mode)
485 {
486  mpsse_clock_data(ctx, out, out_offset, NULL, 0, length, mode);
487 }
488 
489 void mpsse_clock_data_in(struct mpsse_ctx *ctx, uint8_t *in, unsigned in_offset, unsigned length,
490  uint8_t mode)
491 {
492  mpsse_clock_data(ctx, NULL, 0, in, in_offset, length, mode);
493 }
494 
495 void mpsse_clock_data(struct mpsse_ctx *ctx, const uint8_t *out, unsigned out_offset, uint8_t *in,
496  unsigned in_offset, unsigned length, uint8_t mode)
497 {
498  /* TODO: Fix MSB first modes */
499  LOG_DEBUG_IO("%s%s %d bits", in ? "in" : "", out ? "out" : "", length);
500 
501  if (ctx->retval != ERROR_OK) {
502  LOG_DEBUG_IO("Ignoring command due to previous error");
503  return;
504  }
505 
506  /* TODO: On H chips, use command 0x8E/0x8F if in and out are both 0 */
507  if (out || (!out && !in))
508  mode |= 0x10;
509  if (in)
510  mode |= 0x20;
511 
512  while (length > 0) {
513  /* Guarantee buffer space enough for a minimum size transfer */
514  if (buffer_write_space(ctx) + (length < 8) < (out || (!out && !in) ? 4 : 3)
515  || (in && buffer_read_space(ctx) < 1))
516  ctx->retval = mpsse_flush(ctx);
517 
518  if (length < 8) {
519  /* Transfer remaining bits in bit mode */
520  buffer_write_byte(ctx, 0x02 | mode);
521  buffer_write_byte(ctx, length - 1);
522  if (out)
523  out_offset += buffer_write(ctx, out, out_offset, length);
524  if (in)
525  in_offset += buffer_add_read(ctx, in, in_offset, length, 8 - length);
526  if (!out && !in)
527  buffer_write_byte(ctx, 0x00);
528  length = 0;
529  } else {
530  /* Byte transfer */
531  unsigned this_bytes = length / 8;
532  /* MPSSE command limit */
533  if (this_bytes > 65536)
534  this_bytes = 65536;
535  /* Buffer space limit. We already made sure there's space for the minimum
536  * transfer. */
537  if ((out || (!out && !in)) && this_bytes + 3 > buffer_write_space(ctx))
538  this_bytes = buffer_write_space(ctx) - 3;
539  if (in && this_bytes > buffer_read_space(ctx))
540  this_bytes = buffer_read_space(ctx);
541 
542  if (this_bytes > 0) {
543  buffer_write_byte(ctx, mode);
544  buffer_write_byte(ctx, (this_bytes - 1) & 0xff);
545  buffer_write_byte(ctx, (this_bytes - 1) >> 8);
546  if (out)
547  out_offset += buffer_write(ctx,
548  out,
549  out_offset,
550  this_bytes * 8);
551  if (in)
552  in_offset += buffer_add_read(ctx,
553  in,
554  in_offset,
555  this_bytes * 8,
556  0);
557  if (!out && !in)
558  for (unsigned n = 0; n < this_bytes; n++)
559  buffer_write_byte(ctx, 0x00);
560  length -= this_bytes * 8;
561  }
562  }
563  }
564 }
565 
566 void mpsse_clock_tms_cs_out(struct mpsse_ctx *ctx, const uint8_t *out, unsigned out_offset,
567  unsigned length, bool tdi, uint8_t mode)
568 {
569  mpsse_clock_tms_cs(ctx, out, out_offset, NULL, 0, length, tdi, mode);
570 }
571 
572 void mpsse_clock_tms_cs(struct mpsse_ctx *ctx, const uint8_t *out, unsigned out_offset, uint8_t *in,
573  unsigned in_offset, unsigned length, bool tdi, uint8_t mode)
574 {
575  LOG_DEBUG_IO("%sout %d bits, tdi=%d", in ? "in" : "", length, tdi);
576  assert(out);
577 
578  if (ctx->retval != ERROR_OK) {
579  LOG_DEBUG_IO("Ignoring command due to previous error");
580  return;
581  }
582 
583  mode |= 0x42;
584  if (in)
585  mode |= 0x20;
586 
587  while (length > 0) {
588  /* Guarantee buffer space enough for a minimum size transfer */
589  if (buffer_write_space(ctx) < 3 || (in && buffer_read_space(ctx) < 1))
590  ctx->retval = mpsse_flush(ctx);
591 
592  /* Byte transfer */
593  unsigned this_bits = length;
594  /* MPSSE command limit */
595  /* NOTE: there's a report of an FT2232 bug in this area, where shifting
596  * exactly 7 bits can make problems with TMS signaling for the last
597  * clock cycle:
598  *
599  * http://developer.intra2net.com/mailarchive/html/libftdi/2009/msg00292.html
600  */
601  if (this_bits > 7)
602  this_bits = 7;
603 
604  if (this_bits > 0) {
605  buffer_write_byte(ctx, mode);
606  buffer_write_byte(ctx, this_bits - 1);
607  uint8_t data = 0;
608  /* TODO: Fix MSB first, if allowed in MPSSE */
609  bit_copy(&data, 0, out, out_offset, this_bits);
610  out_offset += this_bits;
611  buffer_write_byte(ctx, data | (tdi ? 0x80 : 0x00));
612  if (in)
613  in_offset += buffer_add_read(ctx,
614  in,
615  in_offset,
616  this_bits,
617  8 - this_bits);
618  length -= this_bits;
619  }
620  }
621 }
622 
623 void mpsse_set_data_bits_low_byte(struct mpsse_ctx *ctx, uint8_t data, uint8_t dir)
624 {
625  LOG_DEBUG_IO("-");
626 
627  if (ctx->retval != ERROR_OK) {
628  LOG_DEBUG_IO("Ignoring command due to previous error");
629  return;
630  }
631 
632  if (buffer_write_space(ctx) < 3)
633  ctx->retval = mpsse_flush(ctx);
634 
635  buffer_write_byte(ctx, 0x80);
636  buffer_write_byte(ctx, data);
637  buffer_write_byte(ctx, dir);
638 }
639 
640 void mpsse_set_data_bits_high_byte(struct mpsse_ctx *ctx, uint8_t data, uint8_t dir)
641 {
642  LOG_DEBUG_IO("-");
643 
644  if (ctx->retval != ERROR_OK) {
645  LOG_DEBUG_IO("Ignoring command due to previous error");
646  return;
647  }
648 
649  if (buffer_write_space(ctx) < 3)
650  ctx->retval = mpsse_flush(ctx);
651 
652  buffer_write_byte(ctx, 0x82);
653  buffer_write_byte(ctx, data);
654  buffer_write_byte(ctx, dir);
655 }
656 
657 void mpsse_read_data_bits_low_byte(struct mpsse_ctx *ctx, uint8_t *data)
658 {
659  LOG_DEBUG_IO("-");
660 
661  if (ctx->retval != ERROR_OK) {
662  LOG_DEBUG_IO("Ignoring command due to previous error");
663  return;
664  }
665 
666  if (buffer_write_space(ctx) < 1 || buffer_read_space(ctx) < 1)
667  ctx->retval = mpsse_flush(ctx);
668 
669  buffer_write_byte(ctx, 0x81);
670  buffer_add_read(ctx, data, 0, 8, 0);
671 }
672 
673 void mpsse_read_data_bits_high_byte(struct mpsse_ctx *ctx, uint8_t *data)
674 {
675  LOG_DEBUG_IO("-");
676 
677  if (ctx->retval != ERROR_OK) {
678  LOG_DEBUG_IO("Ignoring command due to previous error");
679  return;
680  }
681 
682  if (buffer_write_space(ctx) < 1 || buffer_read_space(ctx) < 1)
683  ctx->retval = mpsse_flush(ctx);
684 
685  buffer_write_byte(ctx, 0x83);
686  buffer_add_read(ctx, data, 0, 8, 0);
687 }
688 
689 static void single_byte_boolean_helper(struct mpsse_ctx *ctx, bool var, uint8_t val_if_true,
690  uint8_t val_if_false)
691 {
692  if (ctx->retval != ERROR_OK) {
693  LOG_DEBUG_IO("Ignoring command due to previous error");
694  return;
695  }
696 
697  if (buffer_write_space(ctx) < 1)
698  ctx->retval = mpsse_flush(ctx);
699 
700  buffer_write_byte(ctx, var ? val_if_true : val_if_false);
701 }
702 
703 void mpsse_loopback_config(struct mpsse_ctx *ctx, bool enable)
704 {
705  LOG_DEBUG("%s", enable ? "on" : "off");
706  single_byte_boolean_helper(ctx, enable, 0x84, 0x85);
707 }
708 
709 void mpsse_set_divisor(struct mpsse_ctx *ctx, uint16_t divisor)
710 {
711  LOG_DEBUG("%d", divisor);
712 
713  if (ctx->retval != ERROR_OK) {
714  LOG_DEBUG_IO("Ignoring command due to previous error");
715  return;
716  }
717 
718  if (buffer_write_space(ctx) < 3)
719  ctx->retval = mpsse_flush(ctx);
720 
721  buffer_write_byte(ctx, 0x86);
722  buffer_write_byte(ctx, divisor & 0xff);
723  buffer_write_byte(ctx, divisor >> 8);
724 }
725 
726 int mpsse_divide_by_5_config(struct mpsse_ctx *ctx, bool enable)
727 {
728  if (!mpsse_is_high_speed(ctx))
729  return ERROR_FAIL;
730 
731  LOG_DEBUG("%s", enable ? "on" : "off");
732  single_byte_boolean_helper(ctx, enable, 0x8b, 0x8a);
733 
734  return ERROR_OK;
735 }
736 
737 int mpsse_rtck_config(struct mpsse_ctx *ctx, bool enable)
738 {
739  if (!mpsse_is_high_speed(ctx))
740  return ERROR_FAIL;
741 
742  LOG_DEBUG("%s", enable ? "on" : "off");
743  single_byte_boolean_helper(ctx, enable, 0x96, 0x97);
744 
745  return ERROR_OK;
746 }
747 
748 int mpsse_set_frequency(struct mpsse_ctx *ctx, int frequency)
749 {
750  LOG_DEBUG("target %d Hz", frequency);
751  assert(frequency >= 0);
752  int base_clock;
753 
754  if (frequency == 0)
755  return mpsse_rtck_config(ctx, true);
756 
757  mpsse_rtck_config(ctx, false); /* just try */
758 
759  if (frequency > 60000000 / 2 / 65536 && mpsse_divide_by_5_config(ctx, false) == ERROR_OK) {
760  base_clock = 60000000;
761  } else {
762  mpsse_divide_by_5_config(ctx, true); /* just try */
763  base_clock = 12000000;
764  }
765 
766  int divisor = (base_clock / 2 + frequency - 1) / frequency - 1;
767  if (divisor > 65535)
768  divisor = 65535;
769  assert(divisor >= 0);
770 
771  mpsse_set_divisor(ctx, divisor);
772 
773  frequency = base_clock / 2 / (1 + divisor);
774  LOG_DEBUG("actually %d Hz", frequency);
775 
776  return frequency;
777 }
778 
779 /* Context needed by the callbacks */
781  struct mpsse_ctx *ctx;
782  bool done;
783  unsigned transferred;
784 };
785 
786 static LIBUSB_CALL void read_cb(struct libusb_transfer *transfer)
787 {
788  struct transfer_result *res = transfer->user_data;
789  struct mpsse_ctx *ctx = res->ctx;
790 
791  unsigned packet_size = ctx->max_packet_size;
792 
793  DEBUG_PRINT_BUF(transfer->buffer, transfer->actual_length);
794 
795  /* Strip the two status bytes sent at the beginning of each USB packet
796  * while copying the chunk buffer to the read buffer */
797  unsigned num_packets = DIV_ROUND_UP(transfer->actual_length, packet_size);
798  unsigned chunk_remains = transfer->actual_length;
799  for (unsigned i = 0; i < num_packets && chunk_remains > 2; i++) {
800  unsigned this_size = packet_size - 2;
801  if (this_size > chunk_remains - 2)
802  this_size = chunk_remains - 2;
803  if (this_size > ctx->read_count - res->transferred)
804  this_size = ctx->read_count - res->transferred;
805  memcpy(ctx->read_buffer + res->transferred,
806  ctx->read_chunk + packet_size * i + 2,
807  this_size);
808  res->transferred += this_size;
809  chunk_remains -= this_size + 2;
810  if (res->transferred == ctx->read_count) {
811  res->done = true;
812  break;
813  }
814  }
815 
816  LOG_DEBUG_IO("raw chunk %d, transferred %d of %d", transfer->actual_length, res->transferred,
817  ctx->read_count);
818 
819  if (!res->done)
820  if (libusb_submit_transfer(transfer) != LIBUSB_SUCCESS)
821  res->done = true;
822 }
823 
824 static LIBUSB_CALL void write_cb(struct libusb_transfer *transfer)
825 {
826  struct transfer_result *res = transfer->user_data;
827  struct mpsse_ctx *ctx = res->ctx;
828 
829  res->transferred += transfer->actual_length;
830 
831  LOG_DEBUG_IO("transferred %d of %d", res->transferred, ctx->write_count);
832 
833  DEBUG_PRINT_BUF(transfer->buffer, transfer->actual_length);
834 
835  if (res->transferred == ctx->write_count)
836  res->done = true;
837  else {
838  transfer->length = ctx->write_count - res->transferred;
839  transfer->buffer = ctx->write_buffer + res->transferred;
840  if (libusb_submit_transfer(transfer) != LIBUSB_SUCCESS)
841  res->done = true;
842  }
843 }
844 
845 int mpsse_flush(struct mpsse_ctx *ctx)
846 {
847  int retval = ctx->retval;
848 
849  if (retval != ERROR_OK) {
850  LOG_DEBUG_IO("Ignoring flush due to previous error");
851  assert(ctx->write_count == 0 && ctx->read_count == 0);
852  ctx->retval = ERROR_OK;
853  return retval;
854  }
855 
856  LOG_DEBUG_IO("write %d%s, read %d", ctx->write_count, ctx->read_count ? "+1" : "",
857  ctx->read_count);
858  assert(ctx->write_count > 0 || ctx->read_count == 0); /* No read data without write data */
859 
860  if (ctx->write_count == 0)
861  return retval;
862 
863  struct libusb_transfer *read_transfer = NULL;
864  struct transfer_result read_result = { .ctx = ctx, .done = true };
865  if (ctx->read_count) {
866  buffer_write_byte(ctx, 0x87); /* SEND_IMMEDIATE */
867  read_result.done = false;
868  /* delay read transaction to ensure the FTDI chip can support us with data
869  immediately after processing the MPSSE commands in the write transaction */
870  }
871 
872  struct transfer_result write_result = { .ctx = ctx, .done = false };
873  struct libusb_transfer *write_transfer = libusb_alloc_transfer(0);
874  libusb_fill_bulk_transfer(write_transfer, ctx->usb_dev, ctx->out_ep, ctx->write_buffer,
875  ctx->write_count, write_cb, &write_result, ctx->usb_write_timeout);
876  retval = libusb_submit_transfer(write_transfer);
877  if (retval != LIBUSB_SUCCESS)
878  goto error_check;
879 
880  if (ctx->read_count) {
881  read_transfer = libusb_alloc_transfer(0);
882  libusb_fill_bulk_transfer(read_transfer, ctx->usb_dev, ctx->in_ep, ctx->read_chunk,
883  ctx->read_chunk_size, read_cb, &read_result,
884  ctx->usb_read_timeout);
885  retval = libusb_submit_transfer(read_transfer);
886  if (retval != LIBUSB_SUCCESS)
887  goto error_check;
888  }
889 
890  /* Polling loop, more or less taken from libftdi */
891  int64_t start = timeval_ms();
892  int64_t warn_after = 2000;
893  while (!write_result.done || !read_result.done) {
894  struct timeval timeout_usb;
895 
896  timeout_usb.tv_sec = 1;
897  timeout_usb.tv_usec = 0;
898 
899  retval = libusb_handle_events_timeout_completed(ctx->usb_ctx, &timeout_usb, NULL);
900  keep_alive();
901 
902  int64_t now = timeval_ms();
903  if (now - start > warn_after) {
904  LOG_WARNING("Haven't made progress in mpsse_flush() for %" PRId64
905  "ms.", now - start);
906  warn_after *= 2;
907  }
908 
909  if (retval == LIBUSB_ERROR_INTERRUPTED)
910  continue;
911 
912  if (retval != LIBUSB_SUCCESS) {
913  libusb_cancel_transfer(write_transfer);
914  if (read_transfer)
915  libusb_cancel_transfer(read_transfer);
916  }
917  }
918 
919 error_check:
920  if (retval != LIBUSB_SUCCESS) {
921  LOG_ERROR("libusb_handle_events() failed with %s", libusb_error_name(retval));
922  retval = ERROR_FAIL;
923  } else if (write_result.transferred < ctx->write_count) {
924  LOG_ERROR("ftdi device did not accept all data: %d, tried %d",
925  write_result.transferred,
926  ctx->write_count);
927  retval = ERROR_FAIL;
928  } else if (read_result.transferred < ctx->read_count) {
929  LOG_ERROR("ftdi device did not return all data: %d, expected %d",
930  read_result.transferred,
931  ctx->read_count);
932  retval = ERROR_FAIL;
933  } else if (ctx->read_count) {
934  ctx->write_count = 0;
935  ctx->read_count = 0;
937  retval = ERROR_OK;
938  } else {
939  ctx->write_count = 0;
941  retval = ERROR_OK;
942  }
943 
944  if (retval != ERROR_OK)
945  mpsse_purge(ctx);
946 
947  libusb_free_transfer(write_transfer);
948  if (read_transfer)
949  libusb_free_transfer(read_transfer);
950 
951  return retval;
952 }
char * serial
Definition: adapter.c:43
const char * description
Definition: arm_adi_v5.c:1009
enum arm_mode mode
Definition: armv4_5.c:277
static const struct device_t * device
Definition: at91rm9200.c:94
void bit_copy_queue_init(struct bit_copy_queue *q)
Definition: binarybuffer.c:299
void bit_copy_discard(struct bit_copy_queue *q)
Definition: binarybuffer.c:332
int bit_copy_queued(struct bit_copy_queue *q, uint8_t *dst, unsigned dst_offset, const uint8_t *src, unsigned src_offset, unsigned bit_count)
Definition: binarybuffer.c:304
void bit_copy_execute(struct bit_copy_queue *q)
Definition: binarybuffer.c:321
static void bit_copy(uint8_t *dst, unsigned dst_offset, const uint8_t *src, unsigned src_offset, unsigned bit_count)
Definition: binarybuffer.h:202
uint8_t length
Definition: esp_usb_jtag.c:1
bool jtag_libusb_match_ids(struct libusb_device_descriptor *dev_desc, const uint16_t vids[], const uint16_t pids[])
Definition: libusb_helper.c:53
void keep_alive(void)
Definition: log.c:415
static int64_t start
Definition: log.c:42
#define LOG_DEBUG_IO(expr ...)
Definition: log.h:101
#define LOG_WARNING(expr ...)
Definition: log.h:129
#define ERROR_FAIL
Definition: log.h:170
#define LOG_ERROR(expr ...)
Definition: log.h:132
#define LOG_DEBUG(expr ...)
Definition: log.h:109
#define ERROR_OK
Definition: log.h:164
int mpsse_flush(struct mpsse_ctx *ctx)
Definition: mpsse.c:845
void mpsse_clock_data_out(struct mpsse_ctx *ctx, const uint8_t *out, unsigned out_offset, unsigned length, uint8_t mode)
Definition: mpsse.c:483
static unsigned buffer_write(struct mpsse_ctx *ctx, const uint8_t *out, unsigned out_offset, unsigned bit_count)
Definition: mpsse.c:462
static LIBUSB_CALL void write_cb(struct libusb_transfer *transfer)
Definition: mpsse.c:824
void mpsse_read_data_bits_high_byte(struct mpsse_ctx *ctx, uint8_t *data)
Definition: mpsse.c:673
#define BITMODE_MPSSE
Definition: mpsse.c:44
static bool device_location_equal(struct libusb_device *device, const char *location)
Definition: mpsse.c:93
#define SIO_RESET_PURGE_TX
Definition: mpsse.c:53
static unsigned buffer_read_space(struct mpsse_ctx *ctx)
Definition: mpsse.c:450
void mpsse_set_data_bits_high_byte(struct mpsse_ctx *ctx, uint8_t data, uint8_t dir)
Definition: mpsse.c:640
static void buffer_write_byte(struct mpsse_ctx *ctx, uint8_t data)
Definition: mpsse.c:455
static unsigned buffer_add_read(struct mpsse_ctx *ctx, uint8_t *in, unsigned in_offset, unsigned bit_count, unsigned offset)
Definition: mpsse.c:472
static LIBUSB_CALL void read_cb(struct libusb_transfer *transfer)
Definition: mpsse.c:786
#define DEBUG_PRINT_BUF(buf, len)
Definition: mpsse.c:24
void mpsse_set_divisor(struct mpsse_ctx *ctx, uint16_t divisor)
Definition: mpsse.c:709
int mpsse_set_frequency(struct mpsse_ctx *ctx, int frequency)
Definition: mpsse.c:748
void mpsse_read_data_bits_low_byte(struct mpsse_ctx *ctx, uint8_t *data)
Definition: mpsse.c:657
#define SIO_RESET_REQUEST
Definition: mpsse.c:46
static bool string_descriptor_equal(struct libusb_device_handle *device, uint8_t str_index, const char *string)
Definition: mpsse.c:79
static void single_byte_boolean_helper(struct mpsse_ctx *ctx, bool var, uint8_t val_if_true, uint8_t val_if_false)
Definition: mpsse.c:689
#define SIO_SET_LATENCY_TIMER_REQUEST
Definition: mpsse.c:47
void mpsse_purge(struct mpsse_ctx *ctx)
Definition: mpsse.c:421
void mpsse_clock_data_in(struct mpsse_ctx *ctx, uint8_t *in, unsigned in_offset, unsigned length, uint8_t mode)
Definition: mpsse.c:489
struct mpsse_ctx * mpsse_open(const uint16_t vids[], const uint16_t pids[], const char *description, const char *serial, const char *location, int channel)
Definition: mpsse.c:327
bool mpsse_is_high_speed(struct mpsse_ctx *ctx)
Definition: mpsse.c:416
void mpsse_close(struct mpsse_ctx *ctx)
Definition: mpsse.c:402
#define LIBUSB_CALL
Definition: mpsse.c:21
void mpsse_loopback_config(struct mpsse_ctx *ctx, bool enable)
Definition: mpsse.c:703
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:572
void mpsse_set_data_bits_low_byte(struct mpsse_ctx *ctx, uint8_t data, uint8_t dir)
Definition: mpsse.c:623
int mpsse_divide_by_5_config(struct mpsse_ctx *ctx, bool enable)
Definition: mpsse.c:726
#define SIO_RESET_SIO
Definition: mpsse.c:51
static unsigned buffer_write_space(struct mpsse_ctx *ctx)
Definition: mpsse.c:444
int mpsse_rtck_config(struct mpsse_ctx *ctx, bool enable)
Definition: mpsse.c:737
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:566
static bool open_matching_device(struct mpsse_ctx *ctx, const uint16_t vids[], const uint16_t pids[], const char *product, const char *serial, const char *location)
Definition: mpsse.c:152
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:495
#define SIO_RESET_PURGE_RX
Definition: mpsse.c:52
#define SIO_SET_BITMODE_REQUEST
Definition: mpsse.c:49
#define FTDI_DEVICE_OUT_REQTYPE
Definition: mpsse.c:41
ftdi_chip_type
Definition: mpsse.h:22
@ TYPE_FT232HP
Definition: mpsse.h:32
@ TYPE_FT233HP
Definition: mpsse.h:31
@ TYPE_FT2232C
Definition: mpsse.h:23
@ TYPE_FT2232H
Definition: mpsse.h:24
@ TYPE_FT4232HP
Definition: mpsse.h:30
@ TYPE_FT232H
Definition: mpsse.h:26
@ TYPE_FT4232H
Definition: mpsse.h:25
@ TYPE_FT4233HP
Definition: mpsse.h:28
@ TYPE_FT2233HP
Definition: mpsse.h:27
@ TYPE_FT2232HP
Definition: mpsse.h:29
uint8_t * read_buffer
Definition: mpsse.c:69
uint8_t in_ep
Definition: mpsse.c:60
uint16_t index
Definition: mpsse.c:63
unsigned write_size
Definition: mpsse.c:67
int retval
Definition: mpsse.c:75
uint8_t * write_buffer
Definition: mpsse.c:66
uint8_t * read_chunk
Definition: mpsse.c:72
struct libusb_device_handle * usb_dev
Definition: mpsse.c:57
enum ftdi_chip_type type
Definition: mpsse.c:65
unsigned read_chunk_size
Definition: mpsse.c:73
unsigned read_count
Definition: mpsse.c:71
uint8_t interface
Definition: mpsse.c:64
unsigned write_count
Definition: mpsse.c:68
uint16_t max_packet_size
Definition: mpsse.c:62
unsigned int usb_write_timeout
Definition: mpsse.c:58
unsigned int usb_read_timeout
Definition: mpsse.c:59
struct bit_copy_queue read_queue
Definition: mpsse.c:74
uint8_t out_ep
Definition: mpsse.c:61
unsigned read_size
Definition: mpsse.c:70
struct libusb_context * usb_ctx
Definition: mpsse.c:56
long tv_sec
Definition: replacements.h:46
long tv_usec
Definition: replacements.h:47
unsigned transferred
Definition: mpsse.c:783
struct mpsse_ctx * ctx
Definition: mpsse.c:781
int64_t timeval_ms(void)
#define DIV_ROUND_UP(m, n)
Rounds m up to the nearest multiple of n using division.
Definition: types.h:79
#define NULL
Definition: usb.h:16
uint8_t offset[4]
Definition: vdebug.c:9