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