1 /**************************************************************************
2 * Copyright (C) 2012 by Andreas Fritiofson *
3 * andreas.fritiofson@gmail.com *
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. *
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. *
15 * You should have received a copy of the GNU General Public License *
16 * along with this program; if not, write to the *
17 * Free Software Foundation, Inc., *
18 * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
19 ***************************************************************************/
26 #include "helper/log.h"
27 #include <libusb-1.0/libusb.h>
29 /* Compatibility define for older libusb-1.0 */
34 #ifdef _DEBUG_JTAG_IO_
35 #define DEBUG_IO(expr...) LOG_DEBUG(expr)
36 #define DEBUG_PRINT_BUF(buf, len) \
38 char buf_string[32 * 3 + 1]; \
39 int buf_string_pos = 0; \
40 for (int i = 0; i < len; i++) { \
41 buf_string_pos += sprintf(buf_string + buf_string_pos, " %02x", buf[i]); \
42 if (i % 32 == 32 - 1) { \
43 LOG_DEBUG("%s", buf_string); \
47 if (buf_string_pos > 0) \
48 LOG_DEBUG("%s", buf_string);\
51 #define DEBUG_IO(expr...) do {} while (0)
52 #define DEBUG_PRINT_BUF(buf, len) do {} while (0)
55 #define FTDI_DEVICE_OUT_REQTYPE (LIBUSB_REQUEST_TYPE_VENDOR | LIBUSB_RECIPIENT_DEVICE)
56 #define FTDI_DEVICE_IN_REQTYPE (0x80 | LIBUSB_REQUEST_TYPE_VENDOR | LIBUSB_RECIPIENT_DEVICE)
58 #define BITMODE_MPSSE 0x02
60 #define SIO_RESET_REQUEST 0x00
61 #define SIO_SET_LATENCY_TIMER_REQUEST 0x09
62 #define SIO_GET_LATENCY_TIMER_REQUEST 0x0A
63 #define SIO_SET_BITMODE_REQUEST 0x0B
65 #define SIO_RESET_SIO 0
66 #define SIO_RESET_PURGE_RX 1
67 #define SIO_RESET_PURGE_TX 2
70 libusb_context
*usb_ctx
;
71 libusb_device_handle
*usb_dev
;
72 unsigned int usb_write_timeout
;
73 unsigned int usb_read_timeout
;
76 uint16_t max_packet_size
;
79 enum ftdi_chip_type type
;
80 uint8_t *write_buffer
;
87 unsigned read_chunk_size
;
88 struct bit_copy_queue read_queue
;
91 /* Returns true if the string descriptor indexed by str_index in device matches string */
92 static bool string_descriptor_equal(libusb_device_handle
*device
, uint8_t str_index
,
96 char desc_string
[256]; /* Max size of string descriptor */
97 retval
= libusb_get_string_descriptor_ascii(device
, str_index
, (unsigned char *)desc_string
,
100 LOG_ERROR("libusb_get_string_descriptor_ascii() failed with %d", retval
);
103 return strncmp(string
, desc_string
, sizeof(desc_string
)) == 0;
106 /* Helper to open a libusb device that matches vid, pid, product string and/or serial string.
107 * Set any field to 0 as a wildcard. If the device is found true is returned, with ctx containing
108 * the already opened handle. ctx->interface must be set to the desired interface (channel) number
109 * prior to calling this function. */
110 static bool open_matching_device(struct mpsse_ctx
*ctx
, const uint16_t *vid
, const uint16_t *pid
,
111 const char *product
, const char *serial
)
113 libusb_device
**list
;
114 struct libusb_device_descriptor desc
;
115 struct libusb_config_descriptor
*config0
;
118 ssize_t cnt
= libusb_get_device_list(ctx
->usb_ctx
, &list
);
120 LOG_ERROR("libusb_get_device_list() failed with %zi", cnt
);
122 for (ssize_t i
= 0; i
< cnt
; i
++) {
123 libusb_device
*device
= list
[i
];
125 err
= libusb_get_device_descriptor(device
, &desc
);
126 if (err
!= LIBUSB_SUCCESS
) {
127 LOG_ERROR("libusb_get_device_descriptor() failed with %d", err
);
131 if (vid
&& *vid
!= desc
.idVendor
)
133 if (pid
&& *pid
!= desc
.idProduct
)
136 err
= libusb_open(device
, &ctx
->usb_dev
);
137 if (err
!= LIBUSB_SUCCESS
) {
138 LOG_ERROR("libusb_open() failed with %d", err
);
142 if (product
&& !string_descriptor_equal(ctx
->usb_dev
, desc
.iProduct
, product
)) {
143 libusb_close(ctx
->usb_dev
);
147 if (serial
&& !string_descriptor_equal(ctx
->usb_dev
, desc
.iSerialNumber
, serial
)) {
148 libusb_close(ctx
->usb_dev
);
156 libusb_free_device_list(list
, 1);
159 LOG_ERROR("no device found");
163 err
= libusb_get_config_descriptor(libusb_get_device(ctx
->usb_dev
), 0, &config0
);
164 if (err
!= LIBUSB_SUCCESS
) {
165 LOG_ERROR("libusb_get_config_descriptor() failed with %d", err
);
166 libusb_close(ctx
->usb_dev
);
170 /* Make sure the first configuration is selected */
172 err
= libusb_get_configuration(ctx
->usb_dev
, &cfg
);
173 if (err
!= LIBUSB_SUCCESS
) {
174 LOG_ERROR("libusb_get_configuration() failed with %d", err
);
178 if (desc
.bNumConfigurations
> 0 && cfg
!= config0
->bConfigurationValue
) {
179 err
= libusb_set_configuration(ctx
->usb_dev
, config0
->bConfigurationValue
);
180 if (err
!= LIBUSB_SUCCESS
) {
181 LOG_ERROR("libusb_set_configuration() failed with %d", err
);
186 /* Try to detach ftdi_sio kernel module */
187 err
= libusb_detach_kernel_driver(ctx
->usb_dev
, ctx
->interface
);
188 if (err
!= LIBUSB_SUCCESS
&& err
!= LIBUSB_ERROR_NOT_FOUND
189 && err
!= LIBUSB_ERROR_NOT_SUPPORTED
) {
190 LOG_ERROR("libusb_detach_kernel_driver() failed with %d", err
);
194 err
= libusb_claim_interface(ctx
->usb_dev
, ctx
->interface
);
195 if (err
!= LIBUSB_SUCCESS
) {
196 LOG_ERROR("libusb_claim_interface() failed with %d", err
);
200 /* Reset FTDI device */
201 err
= libusb_control_transfer(ctx
->usb_dev
, FTDI_DEVICE_OUT_REQTYPE
,
202 SIO_RESET_REQUEST
, SIO_RESET_SIO
,
203 ctx
->index
, NULL
, 0, ctx
->usb_write_timeout
);
205 LOG_ERROR("failed to reset FTDI device: %d", err
);
209 switch (desc
.bcdDevice
) {
211 ctx
->type
= TYPE_FT2232C
;
214 ctx
->type
= TYPE_FT2232H
;
217 ctx
->type
= TYPE_FT4232H
;
220 ctx
->type
= TYPE_FT232H
;
223 LOG_ERROR("unsupported FTDI chip type: 0x%04x", desc
.bcdDevice
);
227 /* Determine maximum packet size and endpoint addresses */
228 if (!(desc
.bNumConfigurations
> 0 && ctx
->interface
< config0
->bNumInterfaces
229 && config0
->interface
[ctx
->interface
].num_altsetting
> 0))
232 const struct libusb_interface_descriptor
*descriptor
;
233 descriptor
= &config0
->interface
[ctx
->interface
].altsetting
[0];
234 if (descriptor
->bNumEndpoints
!= 2)
239 for (int i
= 0; i
< descriptor
->bNumEndpoints
; i
++) {
240 if (descriptor
->endpoint
[i
].bEndpointAddress
& 0x80) {
241 ctx
->in_ep
= descriptor
->endpoint
[i
].bEndpointAddress
;
242 ctx
->max_packet_size
=
243 descriptor
->endpoint
[i
].wMaxPacketSize
;
245 ctx
->out_ep
= descriptor
->endpoint
[i
].bEndpointAddress
;
249 if (ctx
->in_ep
== 0 || ctx
->out_ep
== 0)
252 libusb_free_config_descriptor(config0
);
256 LOG_ERROR("unrecognized USB device descriptor");
258 libusb_free_config_descriptor(config0
);
259 libusb_close(ctx
->usb_dev
);
263 struct mpsse_ctx
*mpsse_open(const uint16_t *vid
, const uint16_t *pid
, const char *description
,
264 const char *serial
, int channel
)
266 struct mpsse_ctx
*ctx
= calloc(1, sizeof(*ctx
));
272 bit_copy_queue_init(&ctx
->read_queue
);
273 ctx
->read_chunk_size
= 16384;
274 ctx
->read_size
= 16384;
275 ctx
->write_size
= 16384;
276 ctx
->read_chunk
= malloc(ctx
->read_chunk_size
);
277 ctx
->read_buffer
= malloc(ctx
->read_size
);
278 ctx
->write_buffer
= malloc(ctx
->write_size
);
279 if (!ctx
->read_chunk
|| !ctx
->read_buffer
|| !ctx
->write_buffer
)
282 ctx
->interface
= channel
;
283 ctx
->index
= channel
+ 1;
284 ctx
->usb_read_timeout
= 5000;
285 ctx
->usb_write_timeout
= 5000;
287 err
= libusb_init(&ctx
->usb_ctx
);
288 if (err
!= LIBUSB_SUCCESS
) {
289 LOG_ERROR("libusb_init() failed with %d", err
);
293 if (!open_matching_device(ctx
, vid
, pid
, description
, serial
)) {
294 /* Four hex digits plus terminating zero each */
297 LOG_ERROR("unable to open ftdi device with vid %s, pid %s, description '%s' and "
299 vid
? sprintf(vidstr
, "%04x", *vid
), vidstr
: "*",
300 pid
? sprintf(pidstr
, "%04x", *pid
), pidstr
: "*",
301 description
? description
: "*",
302 serial
? serial
: "*");
307 err
= libusb_control_transfer(ctx
->usb_dev
, FTDI_DEVICE_OUT_REQTYPE
,
308 SIO_SET_LATENCY_TIMER_REQUEST
, 255, ctx
->index
, NULL
, 0,
309 ctx
->usb_write_timeout
);
311 LOG_ERROR("unable to set latency timer: %d", err
);
315 err
= libusb_control_transfer(ctx
->usb_dev
,
316 FTDI_DEVICE_OUT_REQTYPE
,
317 SIO_SET_BITMODE_REQUEST
,
318 0x0b | (BITMODE_MPSSE
<< 8),
322 ctx
->usb_write_timeout
);
324 LOG_ERROR("unable to set MPSSE bitmode: %d", err
);
336 void mpsse_close(struct mpsse_ctx
*ctx
)
339 libusb_close(ctx
->usb_dev
);
341 libusb_exit(ctx
->usb_ctx
);
342 bit_copy_discard(&ctx
->read_queue
);
343 if (ctx
->write_buffer
)
344 free(ctx
->write_buffer
);
345 if (ctx
->read_buffer
)
346 free(ctx
->read_buffer
);
348 free(ctx
->read_chunk
);
353 bool mpsse_is_high_speed(struct mpsse_ctx
*ctx
)
355 return ctx
->type
!= TYPE_FT2232C
;
358 void mpsse_purge(struct mpsse_ctx
*ctx
)
362 ctx
->write_count
= 0;
364 bit_copy_discard(&ctx
->read_queue
);
365 err
= libusb_control_transfer(ctx
->usb_dev
, FTDI_DEVICE_OUT_REQTYPE
, SIO_RESET_REQUEST
,
366 SIO_RESET_PURGE_RX
, ctx
->index
, NULL
, 0, ctx
->usb_write_timeout
);
368 LOG_ERROR("unable to purge ftdi rx buffers: %d", err
);
372 err
= libusb_control_transfer(ctx
->usb_dev
, FTDI_DEVICE_OUT_REQTYPE
, SIO_RESET_REQUEST
,
373 SIO_RESET_PURGE_TX
, ctx
->index
, NULL
, 0, ctx
->usb_write_timeout
);
375 LOG_ERROR("unable to purge ftdi tx buffers: %d", err
);
380 static unsigned buffer_write_space(struct mpsse_ctx
*ctx
)
382 /* Reserve one byte for SEND_IMMEDIATE */
383 return ctx
->write_size
- ctx
->write_count
- 1;
386 static unsigned buffer_read_space(struct mpsse_ctx
*ctx
)
388 return ctx
->read_size
- ctx
->read_count
;
391 static void buffer_write_byte(struct mpsse_ctx
*ctx
, uint8_t data
)
393 DEBUG_IO("%02x", data
);
394 assert(ctx
->write_count
< ctx
->write_size
);
395 ctx
->write_buffer
[ctx
->write_count
++] = data
;
398 static unsigned buffer_write(struct mpsse_ctx
*ctx
, const uint8_t *out
, unsigned out_offset
,
401 DEBUG_IO("%d bits", bit_count
);
402 assert(ctx
->write_count
+ DIV_ROUND_UP(bit_count
, 8) <= ctx
->write_size
);
403 bit_copy(ctx
->write_buffer
+ ctx
->write_count
, 0, out
, out_offset
, bit_count
);
404 ctx
->write_count
+= DIV_ROUND_UP(bit_count
, 8);
408 static unsigned buffer_add_read(struct mpsse_ctx
*ctx
, uint8_t *in
, unsigned in_offset
,
409 unsigned bit_count
, unsigned offset
)
411 DEBUG_IO("%d bits, offset %d", bit_count
, offset
);
412 assert(ctx
->read_count
+ DIV_ROUND_UP(bit_count
, 8) <= ctx
->read_size
);
413 bit_copy_queued(&ctx
->read_queue
, in
, in_offset
, ctx
->read_buffer
+ ctx
->read_count
, offset
,
415 ctx
->read_count
+= DIV_ROUND_UP(bit_count
, 8);
419 int mpsse_clock_data_out(struct mpsse_ctx
*ctx
, const uint8_t *out
, unsigned out_offset
,
420 unsigned length
, uint8_t mode
)
422 return mpsse_clock_data(ctx
, out
, out_offset
, 0, 0, length
, mode
);
425 int mpsse_clock_data_in(struct mpsse_ctx
*ctx
, uint8_t *in
, unsigned in_offset
, unsigned length
,
428 return mpsse_clock_data(ctx
, 0, 0, in
, in_offset
, length
, mode
);
431 int mpsse_clock_data(struct mpsse_ctx
*ctx
, const uint8_t *out
, unsigned out_offset
, uint8_t *in
,
432 unsigned in_offset
, unsigned length
, uint8_t mode
)
434 /* TODO: Fix MSB first modes */
435 DEBUG_IO("%s%s %d bits", in
? "in" : "", out
? "out" : "", length
);
436 int retval
= ERROR_OK
;
438 /* TODO: On H chips, use command 0x8E/0x8F if in and out are both 0 */
439 if (out
|| (!out
&& !in
))
445 /* Guarantee buffer space enough for a minimum size transfer */
446 if (buffer_write_space(ctx
) + (length
< 8) < (out
|| (!out
&& !in
) ? 4 : 3)
447 || (in
&& buffer_read_space(ctx
) < 1))
448 retval
= mpsse_flush(ctx
);
451 /* Transfer remaining bits in bit mode */
452 buffer_write_byte(ctx
, 0x02 | mode
);
453 buffer_write_byte(ctx
, length
- 1);
455 out_offset
+= buffer_write(ctx
, out
, out_offset
, length
);
457 in_offset
+= buffer_add_read(ctx
, in
, in_offset
, length
, 8 - length
);
459 buffer_write_byte(ctx
, 0x00);
463 unsigned this_bytes
= length
/ 8;
464 /* MPSSE command limit */
465 if (this_bytes
> 65536)
467 /* Buffer space limit. We already made sure there's space for the minimum
469 if ((out
|| (!out
&& !in
)) && this_bytes
+ 3 > buffer_write_space(ctx
))
470 this_bytes
= buffer_write_space(ctx
) - 3;
471 if (in
&& this_bytes
> buffer_read_space(ctx
))
472 this_bytes
= buffer_read_space(ctx
);
474 if (this_bytes
> 0) {
475 buffer_write_byte(ctx
, mode
);
476 buffer_write_byte(ctx
, (this_bytes
- 1) & 0xff);
477 buffer_write_byte(ctx
, (this_bytes
- 1) >> 8);
479 out_offset
+= buffer_write(ctx
,
484 in_offset
+= buffer_add_read(ctx
,
490 for (unsigned n
= 0; n
< this_bytes
; n
++)
491 buffer_write_byte(ctx
, 0x00);
492 length
-= this_bytes
* 8;
499 int mpsse_clock_tms_cs_out(struct mpsse_ctx
*ctx
, const uint8_t *out
, unsigned out_offset
,
500 unsigned length
, bool tdi
, uint8_t mode
)
502 return mpsse_clock_tms_cs(ctx
, out
, out_offset
, 0, 0, length
, tdi
, mode
);
505 int mpsse_clock_tms_cs(struct mpsse_ctx
*ctx
, const uint8_t *out
, unsigned out_offset
, uint8_t *in
,
506 unsigned in_offset
, unsigned length
, bool tdi
, uint8_t mode
)
508 DEBUG_IO("%sout %d bits, tdi=%d", in
? "in" : "", length
, tdi
);
510 int retval
= ERROR_OK
;
517 /* Guarantee buffer space enough for a minimum size transfer */
518 if (buffer_write_space(ctx
) < 3 || (in
&& buffer_read_space(ctx
) < 1))
519 retval
= mpsse_flush(ctx
);
522 unsigned this_bits
= length
;
523 /* MPSSE command limit */
524 /* NOTE: there's a report of an FT2232 bug in this area, where shifting
525 * exactly 7 bits can make problems with TMS signaling for the last
528 * http://developer.intra2net.com/mailarchive/html/libftdi/2009/msg00292.html
534 buffer_write_byte(ctx
, mode
);
535 buffer_write_byte(ctx
, this_bits
- 1);
537 /* TODO: Fix MSB first, if allowed in MPSSE */
538 bit_copy(&data
, 0, out
, out_offset
, this_bits
);
539 out_offset
+= this_bits
;
540 buffer_write_byte(ctx
, data
| (tdi
? 0x80 : 0x00));
542 in_offset
+= buffer_add_read(ctx
,
553 int mpsse_set_data_bits_low_byte(struct mpsse_ctx
*ctx
, uint8_t data
, uint8_t dir
)
556 int retval
= ERROR_OK
;
558 if (buffer_write_space(ctx
) < 3)
559 retval
= mpsse_flush(ctx
);
561 buffer_write_byte(ctx
, 0x80);
562 buffer_write_byte(ctx
, data
);
563 buffer_write_byte(ctx
, dir
);
568 int mpsse_set_data_bits_high_byte(struct mpsse_ctx
*ctx
, uint8_t data
, uint8_t dir
)
571 int retval
= ERROR_OK
;
573 if (buffer_write_space(ctx
) < 3)
574 retval
= mpsse_flush(ctx
);
576 buffer_write_byte(ctx
, 0x82);
577 buffer_write_byte(ctx
, data
);
578 buffer_write_byte(ctx
, dir
);
583 int mpsse_read_data_bits_low_byte(struct mpsse_ctx
*ctx
, uint8_t *data
)
586 int retval
= ERROR_OK
;
588 if (buffer_write_space(ctx
) < 1)
589 retval
= mpsse_flush(ctx
);
591 buffer_write_byte(ctx
, 0x81);
592 buffer_add_read(ctx
, data
, 0, 8, 0);
597 int mpsse_read_data_bits_high_byte(struct mpsse_ctx
*ctx
, uint8_t *data
)
600 int retval
= ERROR_OK
;
602 if (buffer_write_space(ctx
) < 1)
603 retval
= mpsse_flush(ctx
);
605 buffer_write_byte(ctx
, 0x83);
606 buffer_add_read(ctx
, data
, 0, 8, 0);
611 static int single_byte_boolean_helper(struct mpsse_ctx
*ctx
, bool var
, uint8_t val_if_true
,
612 uint8_t val_if_false
)
614 int retval
= ERROR_OK
;
616 if (buffer_write_space(ctx
) < 1)
617 retval
= mpsse_flush(ctx
);
619 buffer_write_byte(ctx
, var
? val_if_true
: val_if_false
);
624 int mpsse_loopback_config(struct mpsse_ctx
*ctx
, bool enable
)
626 LOG_DEBUG("%s", enable
? "on" : "off");
627 return single_byte_boolean_helper(ctx
, enable
, 0x84, 0x85);
630 int mpsse_set_divisor(struct mpsse_ctx
*ctx
, uint16_t divisor
)
632 LOG_DEBUG("%d", divisor
);
633 int retval
= ERROR_OK
;
635 if (buffer_write_space(ctx
) < 3)
636 retval
= mpsse_flush(ctx
);
638 buffer_write_byte(ctx
, 0x86);
639 buffer_write_byte(ctx
, divisor
& 0xff);
640 buffer_write_byte(ctx
, divisor
>> 8);
645 int mpsse_divide_by_5_config(struct mpsse_ctx
*ctx
, bool enable
)
647 if (!mpsse_is_high_speed(ctx
))
650 LOG_DEBUG("%s", enable
? "on" : "off");
652 return single_byte_boolean_helper(ctx
, enable
, 0x8b, 0x8a);
655 int mpsse_rtck_config(struct mpsse_ctx
*ctx
, bool enable
)
657 if (!mpsse_is_high_speed(ctx
))
660 LOG_DEBUG("%s", enable
? "on" : "off");
662 return single_byte_boolean_helper(ctx
, enable
, 0x96, 0x97);
665 int mpsse_set_frequency(struct mpsse_ctx
*ctx
, int frequency
)
667 LOG_DEBUG("target %d Hz", frequency
);
668 assert(frequency
>= 0);
672 return mpsse_rtck_config(ctx
, true);
674 mpsse_rtck_config(ctx
, false); /* just try */
676 if (frequency
> 60000000 / 2 / 65536 && mpsse_is_high_speed(ctx
)) {
677 int retval
= mpsse_divide_by_5_config(ctx
, false);
678 if (retval
!= ERROR_OK
)
680 base_clock
= 60000000;
682 mpsse_divide_by_5_config(ctx
, true); /* just try */
683 base_clock
= 12000000;
686 int divisor
= (base_clock
/ 2 + frequency
- 1) / frequency
- 1;
689 assert(divisor
>= 0);
691 int retval
= mpsse_set_divisor(ctx
, divisor
);
692 if (retval
!= ERROR_OK
)
695 frequency
= base_clock
/ 2 / (1 + divisor
);
696 LOG_DEBUG("actually %d Hz", frequency
);
701 /* Context needed by the callbacks */
702 struct transfer_result
{
703 struct mpsse_ctx
*ctx
;
705 unsigned transferred
;
708 static LIBUSB_CALL
void read_cb(struct libusb_transfer
*transfer
)
710 struct transfer_result
*res
= (struct transfer_result
*)transfer
->user_data
;
711 struct mpsse_ctx
*ctx
= res
->ctx
;
713 unsigned packet_size
= ctx
->max_packet_size
;
715 DEBUG_PRINT_BUF(transfer
->buffer
, transfer
->actual_length
);
717 /* Strip the two status bytes sent at the beginning of each USB packet
718 * while copying the chunk buffer to the read buffer */
719 unsigned num_packets
= DIV_ROUND_UP(transfer
->actual_length
, packet_size
);
720 unsigned chunk_remains
= transfer
->actual_length
;
721 for (unsigned i
= 0; i
< num_packets
&& chunk_remains
> 2; i
++) {
722 unsigned this_size
= packet_size
- 2;
723 if (this_size
> chunk_remains
- 2)
724 this_size
= chunk_remains
- 2;
725 if (this_size
> ctx
->read_count
- res
->transferred
)
726 this_size
= ctx
->read_count
- res
->transferred
;
727 memcpy(ctx
->read_buffer
+ res
->transferred
,
728 ctx
->read_chunk
+ packet_size
* i
+ 2,
730 res
->transferred
+= this_size
;
731 chunk_remains
-= this_size
+ 2;
732 if (res
->transferred
== ctx
->read_count
) {
738 DEBUG_IO("raw chunk %d, transferred %d of %d", transfer
->actual_length
, res
->transferred
,
742 if (libusb_submit_transfer(transfer
) != LIBUSB_SUCCESS
)
746 static LIBUSB_CALL
void write_cb(struct libusb_transfer
*transfer
)
748 struct transfer_result
*res
= (struct transfer_result
*)transfer
->user_data
;
749 struct mpsse_ctx
*ctx
= res
->ctx
;
751 res
->transferred
+= transfer
->actual_length
;
753 DEBUG_IO("transferred %d of %d", res
->transferred
, ctx
->write_count
);
755 DEBUG_PRINT_BUF(transfer
->buffer
, transfer
->actual_length
);
757 if (res
->transferred
== ctx
->write_count
)
760 transfer
->length
= ctx
->write_count
- res
->transferred
;
761 transfer
->buffer
= ctx
->write_buffer
+ res
->transferred
;
762 if (libusb_submit_transfer(transfer
) != LIBUSB_SUCCESS
)
767 int mpsse_flush(struct mpsse_ctx
*ctx
)
769 DEBUG_IO("write %d%s, read %d", ctx
->write_count
, ctx
->read_count
? "+1" : "",
771 assert(ctx
->write_count
> 0 || ctx
->read_count
== 0); /* No read data without write data */
772 int retval
= ERROR_OK
;
774 if (ctx
->write_count
== 0)
777 struct libusb_transfer
*read_transfer
= 0;
778 struct transfer_result read_result
= { .ctx
= ctx
, .done
= true };
779 if (ctx
->read_count
) {
780 buffer_write_byte(ctx
, 0x87); /* SEND_IMMEDIATE */
781 read_result
.done
= false;
782 /* delay read transaction to ensure the FTDI chip can support us with data
783 immediately after processing the MPSSE commands in the write transaction */
786 struct transfer_result write_result
= { .ctx
= ctx
, .done
= false };
787 struct libusb_transfer
*write_transfer
= libusb_alloc_transfer(0);
788 libusb_fill_bulk_transfer(write_transfer
, ctx
->usb_dev
, ctx
->out_ep
, ctx
->write_buffer
,
789 ctx
->write_count
, write_cb
, &write_result
, ctx
->usb_write_timeout
);
790 retval
= libusb_submit_transfer(write_transfer
);
792 if (ctx
->read_count
) {
793 read_transfer
= libusb_alloc_transfer(0);
794 libusb_fill_bulk_transfer(read_transfer
, ctx
->usb_dev
, ctx
->in_ep
, ctx
->read_chunk
,
795 ctx
->read_chunk_size
, read_cb
, &read_result
,
796 ctx
->usb_read_timeout
);
797 retval
= libusb_submit_transfer(read_transfer
);
800 /* Polling loop, more or less taken from libftdi */
801 while (!write_result
.done
|| !read_result
.done
) {
802 retval
= libusb_handle_events(ctx
->usb_ctx
);
804 if (retval
!= LIBUSB_SUCCESS
&& retval
!= LIBUSB_ERROR_INTERRUPTED
) {
805 libusb_cancel_transfer(write_transfer
);
807 libusb_cancel_transfer(read_transfer
);
808 while (!write_result
.done
|| !read_result
.done
)
809 if (libusb_handle_events(ctx
->usb_ctx
) != LIBUSB_SUCCESS
)
814 if (retval
!= LIBUSB_SUCCESS
) {
815 LOG_ERROR("libusb_handle_events() failed with %d", retval
);
817 } else if (write_result
.transferred
< ctx
->write_count
) {
818 LOG_ERROR("ftdi device did not accept all data: %d, tried %d",
819 write_result
.transferred
,
822 } else if (read_result
.transferred
< ctx
->read_count
) {
823 LOG_ERROR("ftdi device did not return all data: %d, expected %d",
824 read_result
.transferred
,
827 } else if (ctx
->read_count
) {
828 ctx
->write_count
= 0;
830 bit_copy_execute(&ctx
->read_queue
);
833 ctx
->write_count
= 0;
834 bit_copy_discard(&ctx
->read_queue
);
838 libusb_free_transfer(write_transfer
);
840 libusb_free_transfer(read_transfer
);
842 if (retval
!= ERROR_OK
)
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)