Code Review / openocd.git / blob
? search:
summary | shortlog | log | commit | commitdiff | review | tree
history | raw | HEAD
Convert DEBUG_JTAG_IO to LOG_DEBUG_IO
[openocd.git] / src / jtag / drivers / mpsse.c
1 /**************************************************************************
2 * Copyright (C) 2012 by Andreas Fritiofson *
3 * andreas.fritiofson@gmail.com *
4 * *
5 * This program is free software; you can redistribute it and/or modify *
6 * it under the terms of the GNU General Public License as published by *
7 * the Free Software Foundation; either version 2 of the License, or *
8 * (at your option) any later version. *
9 * *
10 * This program is distributed in the hope that it will be useful, *
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
13 * GNU General Public License for more details. *
14 * *
15 * You should have received a copy of the GNU General Public License *
16 * along with this program. If not, see <http://www.gnu.org/licenses/>. *
17 ***************************************************************************/
18
19 #ifdef HAVE_CONFIG_H
20 #include "config.h"
21 #endif
22
23 #include "mpsse.h"
24 #include "helper/log.h"
25 #include <libusb.h>
26
27 /* Compatibility define for older libusb-1.0 */
28 #ifndef LIBUSB_CALL
29 #define LIBUSB_CALL
30 #endif
31
32 #define DEBUG_PRINT_BUF(buf, len) \
33 do { \
34 if (LOG_LEVEL_IS(LOG_LVL_DEBUG_IO)) { \
35 char buf_string[32 * 3 + 1]; \
36 int buf_string_pos = 0; \
37 for (int i = 0; i < len; i++) { \
38 buf_string_pos += sprintf(buf_string + buf_string_pos, " %02x", buf[i]); \
39 if (i % 32 == 32 - 1) { \
40 LOG_DEBUG_IO("%s", buf_string); \
41 buf_string_pos = 0; \
42 } \
43 } \
44 if (buf_string_pos > 0) \
45 LOG_DEBUG_IO("%s", buf_string);\
46 } \
47 } while (0)
48
49 #define FTDI_DEVICE_OUT_REQTYPE (LIBUSB_REQUEST_TYPE_VENDOR | LIBUSB_RECIPIENT_DEVICE)
50 #define FTDI_DEVICE_IN_REQTYPE (0x80 | LIBUSB_REQUEST_TYPE_VENDOR | LIBUSB_RECIPIENT_DEVICE)
51
52 #define BITMODE_MPSSE 0x02
53
54 #define SIO_RESET_REQUEST 0x00
55 #define SIO_SET_LATENCY_TIMER_REQUEST 0x09
56 #define SIO_GET_LATENCY_TIMER_REQUEST 0x0A
57 #define SIO_SET_BITMODE_REQUEST 0x0B
58
59 #define SIO_RESET_SIO 0
60 #define SIO_RESET_PURGE_RX 1
61 #define SIO_RESET_PURGE_TX 2
62
63 struct mpsse_ctx {
64 libusb_context *usb_ctx;
65 libusb_device_handle *usb_dev;
66 unsigned int usb_write_timeout;
67 unsigned int usb_read_timeout;
68 uint8_t in_ep;
69 uint8_t out_ep;
70 uint16_t max_packet_size;
71 uint16_t index;
72 uint8_t interface;
73 enum ftdi_chip_type type;
74 uint8_t *write_buffer;
75 unsigned write_size;
76 unsigned write_count;
77 uint8_t *read_buffer;
78 unsigned read_size;
79 unsigned read_count;
80 uint8_t *read_chunk;
81 unsigned read_chunk_size;
82 struct bit_copy_queue read_queue;
83 int retval;
84 };
85
86 /* Returns true if the string descriptor indexed by str_index in device matches string */
87 static bool string_descriptor_equal(libusb_device_handle *device, uint8_t str_index,
88 const char *string)
89 {
90 int retval;
91 char desc_string[256]; /* Max size of string descriptor */
92 retval = libusb_get_string_descriptor_ascii(device, str_index, (unsigned char *)desc_string,
93 sizeof(desc_string));
94 if (retval < 0) {
95 LOG_ERROR("libusb_get_string_descriptor_ascii() failed with %s", libusb_error_name(retval));
96 return false;
97 }
98 return strncmp(string, desc_string, sizeof(desc_string)) == 0;
99 }
100
101 static bool device_location_equal(libusb_device *device, const char *location)
102 {
103 bool result = false;
104 #ifdef HAVE_LIBUSB_GET_PORT_NUMBERS
105 char *loc = strdup(location);
106 uint8_t port_path[7];
107 int path_step, path_len;
108 uint8_t dev_bus = libusb_get_bus_number(device);
109 char *ptr;
110
111 path_len = libusb_get_port_numbers(device, port_path, 7);
112 if (path_len == LIBUSB_ERROR_OVERFLOW) {
113 LOG_ERROR("cannot determine path to usb device! (more than 7 ports in path)");
114 goto done;
115 }
116
117 LOG_DEBUG("device path has %i steps", path_len);
118
119 ptr = strtok(loc, "-:");
120 if (ptr == NULL) {
121 LOG_DEBUG("no ':' in path");
122 goto done;
123 }
124 if (atoi(ptr) != dev_bus) {
125 LOG_DEBUG("bus mismatch");
126 goto done;
127 }
128
129 path_step = 0;
130 while (path_step < 7) {
131 ptr = strtok(NULL, ".,");
132 if (ptr == NULL) {
133 LOG_DEBUG("no more tokens in path at step %i", path_step);
134 break;
135 }
136
137 if (path_step < path_len
138 && atoi(ptr) != port_path[path_step]) {
139 LOG_DEBUG("path mismatch at step %i", path_step);
140 break;
141 }
142
143 path_step++;
144 };
145
146 /* walked the full path, all elements match */
147 if (path_step == path_len)
148 result = true;
149
150 done:
151 free(loc);
152 #endif
153 return result;
154 }
155
156 /* Helper to open a libusb device that matches vid, pid, product string and/or serial string.
157 * Set any field to 0 as a wildcard. If the device is found true is returned, with ctx containing
158 * the already opened handle. ctx->interface must be set to the desired interface (channel) number
159 * prior to calling this function. */
160 static bool open_matching_device(struct mpsse_ctx *ctx, const uint16_t *vid, const uint16_t *pid,
161 const char *product, const char *serial, const char *location)
162 {
163 libusb_device **list;
164 struct libusb_device_descriptor desc;
165 struct libusb_config_descriptor *config0;
166 int err;
167 bool found = false;
168 ssize_t cnt = libusb_get_device_list(ctx->usb_ctx, &list);
169 if (cnt < 0)
170 LOG_ERROR("libusb_get_device_list() failed with %s", libusb_error_name(cnt));
171
172 for (ssize_t i = 0; i < cnt; i++) {
173 libusb_device *device = list[i];
174
175 err = libusb_get_device_descriptor(device, &desc);
176 if (err != LIBUSB_SUCCESS) {
177 LOG_ERROR("libusb_get_device_descriptor() failed with %s", libusb_error_name(err));
178 continue;
179 }
180
181 if (vid && *vid != desc.idVendor)
182 continue;
183 if (pid && *pid != desc.idProduct)
184 continue;
185
186 err = libusb_open(device, &ctx->usb_dev);
187 if (err != LIBUSB_SUCCESS) {
188 LOG_ERROR("libusb_open() failed with %s",
189 libusb_error_name(err));
190 continue;
191 }
192
193 if (location && !device_location_equal(device, location)) {
194 libusb_close(ctx->usb_dev);
195 continue;
196 }
197
198 if (product && !string_descriptor_equal(ctx->usb_dev, desc.iProduct, product)) {
199 libusb_close(ctx->usb_dev);
200 continue;
201 }
202
203 if (serial && !string_descriptor_equal(ctx->usb_dev, desc.iSerialNumber, serial)) {
204 libusb_close(ctx->usb_dev);
205 continue;
206 }
207
208 found = true;
209 break;
210 }
211
212 libusb_free_device_list(list, 1);
213
214 if (!found) {
215 LOG_ERROR("no device found");
216 return false;
217 }
218
219 err = libusb_get_config_descriptor(libusb_get_device(ctx->usb_dev), 0, &config0);
220 if (err != LIBUSB_SUCCESS) {
221 LOG_ERROR("libusb_get_config_descriptor() failed with %s", libusb_error_name(err));
222 libusb_close(ctx->usb_dev);
223 return false;
224 }
225
226 /* Make sure the first configuration is selected */
227 int cfg;
228 err = libusb_get_configuration(ctx->usb_dev, &cfg);
229 if (err != LIBUSB_SUCCESS) {
230 LOG_ERROR("libusb_get_configuration() failed with %s", libusb_error_name(err));
231 goto error;
232 }
233
234 if (desc.bNumConfigurations > 0 && cfg != config0->bConfigurationValue) {
235 err = libusb_set_configuration(ctx->usb_dev, config0->bConfigurationValue);
236 if (err != LIBUSB_SUCCESS) {
237 LOG_ERROR("libusb_set_configuration() failed with %s", libusb_error_name(err));
238 goto error;
239 }
240 }
241
242 /* Try to detach ftdi_sio kernel module */
243 err = libusb_detach_kernel_driver(ctx->usb_dev, ctx->interface);
244 if (err != LIBUSB_SUCCESS && err != LIBUSB_ERROR_NOT_FOUND
245 && err != LIBUSB_ERROR_NOT_SUPPORTED) {
246 LOG_WARNING("libusb_detach_kernel_driver() failed with %s, trying to continue anyway",
247 libusb_error_name(err));
248 }
249
250 err = libusb_claim_interface(ctx->usb_dev, ctx->interface);
251 if (err != LIBUSB_SUCCESS) {
252 LOG_ERROR("libusb_claim_interface() failed with %s", libusb_error_name(err));
253 goto error;
254 }
255
256 /* Reset FTDI device */
257 err = libusb_control_transfer(ctx->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
258 SIO_RESET_REQUEST, SIO_RESET_SIO,
259 ctx->index, NULL, 0, ctx->usb_write_timeout);
260 if (err < 0) {
261 LOG_ERROR("failed to reset FTDI device: %s", libusb_error_name(err));
262 goto error;
263 }
264
265 switch (desc.bcdDevice) {
266 case 0x500:
267 ctx->type = TYPE_FT2232C;
268 break;
269 case 0x700:
270 ctx->type = TYPE_FT2232H;
271 break;
272 case 0x800:
273 ctx->type = TYPE_FT4232H;
274 break;
275 case 0x900:
276 ctx->type = TYPE_FT232H;
277 break;
278 default:
279 LOG_ERROR("unsupported FTDI chip type: 0x%04x", desc.bcdDevice);
280 goto error;
281 }
282
283 /* Determine maximum packet size and endpoint addresses */
284 if (!(desc.bNumConfigurations > 0 && ctx->interface < config0->bNumInterfaces
285 && config0->interface[ctx->interface].num_altsetting > 0))
286 goto desc_error;
287
288 const struct libusb_interface_descriptor *descriptor;
289 descriptor = &config0->interface[ctx->interface].altsetting[0];
290 if (descriptor->bNumEndpoints != 2)
291 goto desc_error;
292
293 ctx->in_ep = 0;
294 ctx->out_ep = 0;
295 for (int i = 0; i < descriptor->bNumEndpoints; i++) {
296 if (descriptor->endpoint[i].bEndpointAddress & 0x80) {
297 ctx->in_ep = descriptor->endpoint[i].bEndpointAddress;
298 ctx->max_packet_size =
299 descriptor->endpoint[i].wMaxPacketSize;
300 } else {
301 ctx->out_ep = descriptor->endpoint[i].bEndpointAddress;
302 }
303 }
304
305 if (ctx->in_ep == 0 || ctx->out_ep == 0)
306 goto desc_error;
307
308 libusb_free_config_descriptor(config0);
309 return true;
310
311 desc_error:
312 LOG_ERROR("unrecognized USB device descriptor");
313 error:
314 libusb_free_config_descriptor(config0);
315 libusb_close(ctx->usb_dev);
316 return false;
317 }
318
319 struct mpsse_ctx *mpsse_open(const uint16_t *vid, const uint16_t *pid, const char *description,
320 const char *serial, const char *location, int channel)
321 {
322 struct mpsse_ctx *ctx = calloc(1, sizeof(*ctx));
323 int err;
324
325 if (!ctx)
326 return 0;
327
328 bit_copy_queue_init(&ctx->read_queue);
329 ctx->read_chunk_size = 16384;
330 ctx->read_size = 16384;
331 ctx->write_size = 16384;
332 ctx->read_chunk = malloc(ctx->read_chunk_size);
333 ctx->read_buffer = malloc(ctx->read_size);
334
335 /* Use calloc to make valgrind happy: buffer_write() sets payload
336 * on bit basis, so some bits can be left uninitialized in write_buffer.
337 * Although this is perfectly ok with MPSSE, valgrind reports
338 * Syscall param ioctl(USBDEVFS_SUBMITURB).buffer points to uninitialised byte(s) */
339 ctx->write_buffer = calloc(1, ctx->write_size);
340
341 if (!ctx->read_chunk || !ctx->read_buffer || !ctx->write_buffer)
342 goto error;
343
344 ctx->interface = channel;
345 ctx->index = channel + 1;
346 ctx->usb_read_timeout = 5000;
347 ctx->usb_write_timeout = 5000;
348
349 err = libusb_init(&ctx->usb_ctx);
350 if (err != LIBUSB_SUCCESS) {
351 LOG_ERROR("libusb_init() failed with %s", libusb_error_name(err));
352 goto error;
353 }
354
355 if (!open_matching_device(ctx, vid, pid, description, serial, location)) {
356 /* Four hex digits plus terminating zero each */
357 char vidstr[5];
358 char pidstr[5];
359 LOG_ERROR("unable to open ftdi device with vid %s, pid %s, description '%s', "
360 "serial '%s' at bus location '%s'",
361 vid ? sprintf(vidstr, "%04x", *vid), vidstr : "*",
362 pid ? sprintf(pidstr, "%04x", *pid), pidstr : "*",
363 description ? description : "*",
364 serial ? serial : "*",
365 location ? location : "*");
366 ctx->usb_dev = 0;
367 goto error;
368 }
369
370 err = libusb_control_transfer(ctx->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
371 SIO_SET_LATENCY_TIMER_REQUEST, 255, ctx->index, NULL, 0,
372 ctx->usb_write_timeout);
373 if (err < 0) {
374 LOG_ERROR("unable to set latency timer: %s", libusb_error_name(err));
375 goto error;
376 }
377
378 err = libusb_control_transfer(ctx->usb_dev,
379 FTDI_DEVICE_OUT_REQTYPE,
380 SIO_SET_BITMODE_REQUEST,
381 0x0b | (BITMODE_MPSSE << 8),
382 ctx->index,
383 NULL,
384 0,
385 ctx->usb_write_timeout);
386 if (err < 0) {
387 LOG_ERROR("unable to set MPSSE bitmode: %s", libusb_error_name(err));
388 goto error;
389 }
390
391 mpsse_purge(ctx);
392
393 return ctx;
394 error:
395 mpsse_close(ctx);
396 return 0;
397 }
398
399 void mpsse_close(struct mpsse_ctx *ctx)
400 {
401 if (ctx->usb_dev)
402 libusb_close(ctx->usb_dev);
403 if (ctx->usb_ctx)
404 libusb_exit(ctx->usb_ctx);
405 bit_copy_discard(&ctx->read_queue);
406 if (ctx->write_buffer)
407 free(ctx->write_buffer);
408 if (ctx->read_buffer)
409 free(ctx->read_buffer);
410 if (ctx->read_chunk)
411 free(ctx->read_chunk);
412
413 free(ctx);
414 }
415
416 bool mpsse_is_high_speed(struct mpsse_ctx *ctx)
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;
428 bit_copy_discard(&ctx->read_queue);
429 err = libusb_control_transfer(ctx->usb_dev, FTDI_DEVICE_OUT_REQTYPE, SIO_RESET_REQUEST,
430 SIO_RESET_PURGE_RX, ctx->index, NULL, 0, ctx->usb_write_timeout);
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,
437 SIO_RESET_PURGE_TX, ctx->index, NULL, 0, ctx->usb_write_timeout);
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, 0, 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, 0, 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, 0, 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 */
780 struct transfer_result {
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 = 0;
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 while (!write_result.done || !read_result.done) {
892 struct timeval timeout_usb;
893
894 timeout_usb.tv_sec = 1;
895 timeout_usb.tv_usec = 0;
896
897 retval = libusb_handle_events_timeout_completed(ctx->usb_ctx, &timeout_usb, NULL);
898 keep_alive();
899 if (retval == LIBUSB_ERROR_NO_DEVICE || retval == LIBUSB_ERROR_INTERRUPTED)
900 break;
901
902 if (retval != LIBUSB_SUCCESS) {
903 libusb_cancel_transfer(write_transfer);
904 if (read_transfer)
905 libusb_cancel_transfer(read_transfer);
906 while (!write_result.done || !read_result.done) {
907 retval = libusb_handle_events_timeout_completed(ctx->usb_ctx,
908 &timeout_usb, NULL);
909 if (retval != LIBUSB_SUCCESS)
910 break;
911 }
912 }
913 }
914
915 error_check:
916 if (retval != LIBUSB_SUCCESS) {
917 LOG_ERROR("libusb_handle_events() failed with %s", libusb_error_name(retval));
918 retval = ERROR_FAIL;
919 } else if (write_result.transferred < ctx->write_count) {
920 LOG_ERROR("ftdi device did not accept all data: %d, tried %d",
921 write_result.transferred,
922 ctx->write_count);
923 retval = ERROR_FAIL;
924 } else if (read_result.transferred < ctx->read_count) {
925 LOG_ERROR("ftdi device did not return all data: %d, expected %d",
926 read_result.transferred,
927 ctx->read_count);
928 retval = ERROR_FAIL;
929 } else if (ctx->read_count) {
930 ctx->write_count = 0;
931 ctx->read_count = 0;
932 bit_copy_execute(&ctx->read_queue);
933 retval = ERROR_OK;
934 } else {
935 ctx->write_count = 0;
936 bit_copy_discard(&ctx->read_queue);
937 retval = ERROR_OK;
938 }
939
940 libusb_free_transfer(write_transfer);
941 if (read_transfer)
942 libusb_free_transfer(read_transfer);
943
944 if (retval != ERROR_OK)
945 mpsse_purge(ctx);
946
947 return retval;
948 }
Open On-Chip Debugger

Linking to existing account procedure

If you already have an account and want to add another login method you MUST first sign in with your existing account and then change URL to read https://review.openocd.org/login/?link to get to this page again but this time it'll work for linking. Thank you.

SSH host keys fingerprints

1024 SHA256:YKx8b7u5ZWdcbp7/4AeXNaqElP49m6QrwfXaqQGJAOk gerrit-code-review@openocd.zylin.com (DSA)
384 SHA256:jHIbSQa4REvwCFG4cq5LBlBLxmxSqelQPem/EXIrxjk gerrit-code-review@openocd.org (ECDSA)
521 SHA256:UAOPYkU9Fjtcao0Ul/Rrlnj/OsQvt+pgdYSZ4jOYdgs gerrit-code-review@openocd.org (ECDSA)
256 SHA256:A13M5QlnozFOvTllybRZH6vm7iSt0XLxbA48yfc2yfY gerrit-code-review@openocd.org (ECDSA)
256 SHA256:spYMBqEYoAOtK7yZBrcwE8ZpYt6b68Cfh9yEVetvbXg gerrit-code-review@openocd.org (ED25519)
+--[ED25519 256]--+
|=..              |
|+o..   .         |
|*.o   . .        |
|+B . . .         |
|Bo. = o S        |
|Oo.+ + =         |
|oB=.* = . o      |
| =+=.+   + E     |
|. .=o   . o      |
+----[SHA256]-----+
2048 SHA256:0Onrb7/PHjpo6iVZ7xQX2riKN83FJ3KGU0TvI0TaFG4 gerrit-code-review@openocd.zylin.com (RSA)