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 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. *
19 ***************************************************************************/
26 #include "helper/log.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
;
92 /* Returns true if the string descriptor indexed by str_index in device matches string */
93 static bool string_descriptor_equal(libusb_device_handle
*device
, uint8_t str_index
,
97 char desc_string
[256]; /* Max size of string descriptor */
98 retval
= libusb_get_string_descriptor_ascii(device
, str_index
, (unsigned char *)desc_string
,
101 LOG_ERROR("libusb_get_string_descriptor_ascii() failed with %d", retval
);
104 return strncmp(string
, desc_string
, sizeof(desc_string
)) == 0;
107 /* Helper to open a libusb device that matches vid, pid, product string and/or serial string.
108 * Set any field to 0 as a wildcard. If the device is found true is returned, with ctx containing
109 * the already opened handle. ctx->interface must be set to the desired interface (channel) number
110 * prior to calling this function. */
111 static bool open_matching_device(struct mpsse_ctx
*ctx
, const uint16_t *vid
, const uint16_t *pid
,
112 const char *product
, const char *serial
)
114 libusb_device
**list
;
115 struct libusb_device_descriptor desc
;
116 struct libusb_config_descriptor
*config0
;
119 ssize_t cnt
= libusb_get_device_list(ctx
->usb_ctx
, &list
);
121 LOG_ERROR("libusb_get_device_list() failed with %zi", cnt
);
123 for (ssize_t i
= 0; i
< cnt
; i
++) {
124 libusb_device
*device
= list
[i
];
126 err
= libusb_get_device_descriptor(device
, &desc
);
127 if (err
!= LIBUSB_SUCCESS
) {
128 LOG_ERROR("libusb_get_device_descriptor() failed with %d", err
);
132 if (vid
&& *vid
!= desc
.idVendor
)
134 if (pid
&& *pid
!= desc
.idProduct
)
137 err
= libusb_open(device
, &ctx
->usb_dev
);
138 if (err
!= LIBUSB_SUCCESS
) {
139 LOG_ERROR("libusb_open() failed with %s",
140 libusb_error_name(err
));
144 if (product
&& !string_descriptor_equal(ctx
->usb_dev
, desc
.iProduct
, product
)) {
145 libusb_close(ctx
->usb_dev
);
149 if (serial
&& !string_descriptor_equal(ctx
->usb_dev
, desc
.iSerialNumber
, serial
)) {
150 libusb_close(ctx
->usb_dev
);
158 libusb_free_device_list(list
, 1);
161 LOG_ERROR("no device found");
165 err
= libusb_get_config_descriptor(libusb_get_device(ctx
->usb_dev
), 0, &config0
);
166 if (err
!= LIBUSB_SUCCESS
) {
167 LOG_ERROR("libusb_get_config_descriptor() failed with %d", err
);
168 libusb_close(ctx
->usb_dev
);
172 /* Make sure the first configuration is selected */
174 err
= libusb_get_configuration(ctx
->usb_dev
, &cfg
);
175 if (err
!= LIBUSB_SUCCESS
) {
176 LOG_ERROR("libusb_get_configuration() failed with %d", err
);
180 if (desc
.bNumConfigurations
> 0 && cfg
!= config0
->bConfigurationValue
) {
181 err
= libusb_set_configuration(ctx
->usb_dev
, config0
->bConfigurationValue
);
182 if (err
!= LIBUSB_SUCCESS
) {
183 LOG_ERROR("libusb_set_configuration() failed with %d", err
);
188 /* Try to detach ftdi_sio kernel module */
189 err
= libusb_detach_kernel_driver(ctx
->usb_dev
, ctx
->interface
);
190 if (err
!= LIBUSB_SUCCESS
&& err
!= LIBUSB_ERROR_NOT_FOUND
191 && err
!= LIBUSB_ERROR_NOT_SUPPORTED
) {
192 LOG_ERROR("libusb_detach_kernel_driver() failed with %d", err
);
196 err
= libusb_claim_interface(ctx
->usb_dev
, ctx
->interface
);
197 if (err
!= LIBUSB_SUCCESS
) {
198 LOG_ERROR("libusb_claim_interface() failed with %d", err
);
202 /* Reset FTDI device */
203 err
= libusb_control_transfer(ctx
->usb_dev
, FTDI_DEVICE_OUT_REQTYPE
,
204 SIO_RESET_REQUEST
, SIO_RESET_SIO
,
205 ctx
->index
, NULL
, 0, ctx
->usb_write_timeout
);
207 LOG_ERROR("failed to reset FTDI device: %d", err
);
211 switch (desc
.bcdDevice
) {
213 ctx
->type
= TYPE_FT2232C
;
216 ctx
->type
= TYPE_FT2232H
;
219 ctx
->type
= TYPE_FT4232H
;
222 ctx
->type
= TYPE_FT232H
;
225 LOG_ERROR("unsupported FTDI chip type: 0x%04x", desc
.bcdDevice
);
229 /* Determine maximum packet size and endpoint addresses */
230 if (!(desc
.bNumConfigurations
> 0 && ctx
->interface
< config0
->bNumInterfaces
231 && config0
->interface
[ctx
->interface
].num_altsetting
> 0))
234 const struct libusb_interface_descriptor
*descriptor
;
235 descriptor
= &config0
->interface
[ctx
->interface
].altsetting
[0];
236 if (descriptor
->bNumEndpoints
!= 2)
241 for (int i
= 0; i
< descriptor
->bNumEndpoints
; i
++) {
242 if (descriptor
->endpoint
[i
].bEndpointAddress
& 0x80) {
243 ctx
->in_ep
= descriptor
->endpoint
[i
].bEndpointAddress
;
244 ctx
->max_packet_size
=
245 descriptor
->endpoint
[i
].wMaxPacketSize
;
247 ctx
->out_ep
= descriptor
->endpoint
[i
].bEndpointAddress
;
251 if (ctx
->in_ep
== 0 || ctx
->out_ep
== 0)
254 libusb_free_config_descriptor(config0
);
258 LOG_ERROR("unrecognized USB device descriptor");
260 libusb_free_config_descriptor(config0
);
261 libusb_close(ctx
->usb_dev
);
265 struct mpsse_ctx
*mpsse_open(const uint16_t *vid
, const uint16_t *pid
, const char *description
,
266 const char *serial
, int channel
)
268 struct mpsse_ctx
*ctx
= calloc(1, sizeof(*ctx
));
274 bit_copy_queue_init(&ctx
->read_queue
);
275 ctx
->read_chunk_size
= 16384;
276 ctx
->read_size
= 16384;
277 ctx
->write_size
= 16384;
278 ctx
->read_chunk
= malloc(ctx
->read_chunk_size
);
279 ctx
->read_buffer
= malloc(ctx
->read_size
);
280 ctx
->write_buffer
= malloc(ctx
->write_size
);
281 if (!ctx
->read_chunk
|| !ctx
->read_buffer
|| !ctx
->write_buffer
)
284 ctx
->interface
= channel
;
285 ctx
->index
= channel
+ 1;
286 ctx
->usb_read_timeout
= 5000;
287 ctx
->usb_write_timeout
= 5000;
289 err
= libusb_init(&ctx
->usb_ctx
);
290 if (err
!= LIBUSB_SUCCESS
) {
291 LOG_ERROR("libusb_init() failed with %d", err
);
295 if (!open_matching_device(ctx
, vid
, pid
, description
, serial
)) {
296 /* Four hex digits plus terminating zero each */
299 LOG_ERROR("unable to open ftdi device with vid %s, pid %s, description '%s' and "
301 vid
? sprintf(vidstr
, "%04x", *vid
), vidstr
: "*",
302 pid
? sprintf(pidstr
, "%04x", *pid
), pidstr
: "*",
303 description
? description
: "*",
304 serial
? serial
: "*");
309 err
= libusb_control_transfer(ctx
->usb_dev
, FTDI_DEVICE_OUT_REQTYPE
,
310 SIO_SET_LATENCY_TIMER_REQUEST
, 255, ctx
->index
, NULL
, 0,
311 ctx
->usb_write_timeout
);
313 LOG_ERROR("unable to set latency timer: %d", err
);
317 err
= libusb_control_transfer(ctx
->usb_dev
,
318 FTDI_DEVICE_OUT_REQTYPE
,
319 SIO_SET_BITMODE_REQUEST
,
320 0x0b | (BITMODE_MPSSE
<< 8),
324 ctx
->usb_write_timeout
);
326 LOG_ERROR("unable to set MPSSE bitmode: %d", err
);
338 void mpsse_close(struct mpsse_ctx
*ctx
)
341 libusb_close(ctx
->usb_dev
);
343 libusb_exit(ctx
->usb_ctx
);
344 bit_copy_discard(&ctx
->read_queue
);
345 if (ctx
->write_buffer
)
346 free(ctx
->write_buffer
);
347 if (ctx
->read_buffer
)
348 free(ctx
->read_buffer
);
350 free(ctx
->read_chunk
);
355 bool mpsse_is_high_speed(struct mpsse_ctx
*ctx
)
357 return ctx
->type
!= TYPE_FT2232C
;
360 void mpsse_purge(struct mpsse_ctx
*ctx
)
364 ctx
->write_count
= 0;
366 ctx
->retval
= ERROR_OK
;
367 bit_copy_discard(&ctx
->read_queue
);
368 err
= libusb_control_transfer(ctx
->usb_dev
, FTDI_DEVICE_OUT_REQTYPE
, SIO_RESET_REQUEST
,
369 SIO_RESET_PURGE_RX
, ctx
->index
, NULL
, 0, ctx
->usb_write_timeout
);
371 LOG_ERROR("unable to purge ftdi rx buffers: %d", err
);
375 err
= libusb_control_transfer(ctx
->usb_dev
, FTDI_DEVICE_OUT_REQTYPE
, SIO_RESET_REQUEST
,
376 SIO_RESET_PURGE_TX
, ctx
->index
, NULL
, 0, ctx
->usb_write_timeout
);
378 LOG_ERROR("unable to purge ftdi tx buffers: %d", err
);
383 static unsigned buffer_write_space(struct mpsse_ctx
*ctx
)
385 /* Reserve one byte for SEND_IMMEDIATE */
386 return ctx
->write_size
- ctx
->write_count
- 1;
389 static unsigned buffer_read_space(struct mpsse_ctx
*ctx
)
391 return ctx
->read_size
- ctx
->read_count
;
394 static void buffer_write_byte(struct mpsse_ctx
*ctx
, uint8_t data
)
396 DEBUG_IO("%02x", data
);
397 assert(ctx
->write_count
< ctx
->write_size
);
398 ctx
->write_buffer
[ctx
->write_count
++] = data
;
401 static unsigned buffer_write(struct mpsse_ctx
*ctx
, const uint8_t *out
, unsigned out_offset
,
404 DEBUG_IO("%d bits", bit_count
);
405 assert(ctx
->write_count
+ DIV_ROUND_UP(bit_count
, 8) <= ctx
->write_size
);
406 bit_copy(ctx
->write_buffer
+ ctx
->write_count
, 0, out
, out_offset
, bit_count
);
407 ctx
->write_count
+= DIV_ROUND_UP(bit_count
, 8);
411 static unsigned buffer_add_read(struct mpsse_ctx
*ctx
, uint8_t *in
, unsigned in_offset
,
412 unsigned bit_count
, unsigned offset
)
414 DEBUG_IO("%d bits, offset %d", bit_count
, offset
);
415 assert(ctx
->read_count
+ DIV_ROUND_UP(bit_count
, 8) <= ctx
->read_size
);
416 bit_copy_queued(&ctx
->read_queue
, in
, in_offset
, ctx
->read_buffer
+ ctx
->read_count
, offset
,
418 ctx
->read_count
+= DIV_ROUND_UP(bit_count
, 8);
422 void mpsse_clock_data_out(struct mpsse_ctx
*ctx
, const uint8_t *out
, unsigned out_offset
,
423 unsigned length
, uint8_t mode
)
425 mpsse_clock_data(ctx
, out
, out_offset
, 0, 0, length
, mode
);
428 void mpsse_clock_data_in(struct mpsse_ctx
*ctx
, uint8_t *in
, unsigned in_offset
, unsigned length
,
431 mpsse_clock_data(ctx
, 0, 0, in
, in_offset
, length
, mode
);
434 void mpsse_clock_data(struct mpsse_ctx
*ctx
, const uint8_t *out
, unsigned out_offset
, uint8_t *in
,
435 unsigned in_offset
, unsigned length
, uint8_t mode
)
437 /* TODO: Fix MSB first modes */
438 DEBUG_IO("%s%s %d bits", in
? "in" : "", out
? "out" : "", length
);
440 if (ctx
->retval
!= ERROR_OK
) {
441 DEBUG_IO("Ignoring command due to previous error");
445 /* TODO: On H chips, use command 0x8E/0x8F if in and out are both 0 */
446 if (out
|| (!out
&& !in
))
452 /* Guarantee buffer space enough for a minimum size transfer */
453 if (buffer_write_space(ctx
) + (length
< 8) < (out
|| (!out
&& !in
) ? 4 : 3)
454 || (in
&& buffer_read_space(ctx
) < 1))
455 ctx
->retval
= mpsse_flush(ctx
);
458 /* Transfer remaining bits in bit mode */
459 buffer_write_byte(ctx
, 0x02 | mode
);
460 buffer_write_byte(ctx
, length
- 1);
462 out_offset
+= buffer_write(ctx
, out
, out_offset
, length
);
464 in_offset
+= buffer_add_read(ctx
, in
, in_offset
, length
, 8 - length
);
466 buffer_write_byte(ctx
, 0x00);
470 unsigned this_bytes
= length
/ 8;
471 /* MPSSE command limit */
472 if (this_bytes
> 65536)
474 /* Buffer space limit. We already made sure there's space for the minimum
476 if ((out
|| (!out
&& !in
)) && this_bytes
+ 3 > buffer_write_space(ctx
))
477 this_bytes
= buffer_write_space(ctx
) - 3;
478 if (in
&& this_bytes
> buffer_read_space(ctx
))
479 this_bytes
= buffer_read_space(ctx
);
481 if (this_bytes
> 0) {
482 buffer_write_byte(ctx
, mode
);
483 buffer_write_byte(ctx
, (this_bytes
- 1) & 0xff);
484 buffer_write_byte(ctx
, (this_bytes
- 1) >> 8);
486 out_offset
+= buffer_write(ctx
,
491 in_offset
+= buffer_add_read(ctx
,
497 for (unsigned n
= 0; n
< this_bytes
; n
++)
498 buffer_write_byte(ctx
, 0x00);
499 length
-= this_bytes
* 8;
505 void mpsse_clock_tms_cs_out(struct mpsse_ctx
*ctx
, const uint8_t *out
, unsigned out_offset
,
506 unsigned length
, bool tdi
, uint8_t mode
)
508 mpsse_clock_tms_cs(ctx
, out
, out_offset
, 0, 0, length
, tdi
, mode
);
511 void mpsse_clock_tms_cs(struct mpsse_ctx
*ctx
, const uint8_t *out
, unsigned out_offset
, uint8_t *in
,
512 unsigned in_offset
, unsigned length
, bool tdi
, uint8_t mode
)
514 DEBUG_IO("%sout %d bits, tdi=%d", in
? "in" : "", length
, tdi
);
517 if (ctx
->retval
!= ERROR_OK
) {
518 DEBUG_IO("Ignoring command due to previous error");
527 /* Guarantee buffer space enough for a minimum size transfer */
528 if (buffer_write_space(ctx
) < 3 || (in
&& buffer_read_space(ctx
) < 1))
529 ctx
->retval
= mpsse_flush(ctx
);
532 unsigned this_bits
= length
;
533 /* MPSSE command limit */
534 /* NOTE: there's a report of an FT2232 bug in this area, where shifting
535 * exactly 7 bits can make problems with TMS signaling for the last
538 * http://developer.intra2net.com/mailarchive/html/libftdi/2009/msg00292.html
544 buffer_write_byte(ctx
, mode
);
545 buffer_write_byte(ctx
, this_bits
- 1);
547 /* TODO: Fix MSB first, if allowed in MPSSE */
548 bit_copy(&data
, 0, out
, out_offset
, this_bits
);
549 out_offset
+= this_bits
;
550 buffer_write_byte(ctx
, data
| (tdi
? 0x80 : 0x00));
552 in_offset
+= buffer_add_read(ctx
,
562 void mpsse_set_data_bits_low_byte(struct mpsse_ctx
*ctx
, uint8_t data
, uint8_t dir
)
566 if (ctx
->retval
!= ERROR_OK
) {
567 DEBUG_IO("Ignoring command due to previous error");
571 if (buffer_write_space(ctx
) < 3)
572 ctx
->retval
= mpsse_flush(ctx
);
574 buffer_write_byte(ctx
, 0x80);
575 buffer_write_byte(ctx
, data
);
576 buffer_write_byte(ctx
, dir
);
579 void mpsse_set_data_bits_high_byte(struct mpsse_ctx
*ctx
, uint8_t data
, uint8_t dir
)
583 if (ctx
->retval
!= ERROR_OK
) {
584 DEBUG_IO("Ignoring command due to previous error");
588 if (buffer_write_space(ctx
) < 3)
589 ctx
->retval
= mpsse_flush(ctx
);
591 buffer_write_byte(ctx
, 0x82);
592 buffer_write_byte(ctx
, data
);
593 buffer_write_byte(ctx
, dir
);
596 void mpsse_read_data_bits_low_byte(struct mpsse_ctx
*ctx
, uint8_t *data
)
600 if (ctx
->retval
!= ERROR_OK
) {
601 DEBUG_IO("Ignoring command due to previous error");
605 if (buffer_write_space(ctx
) < 1 || buffer_read_space(ctx
) < 1)
606 ctx
->retval
= mpsse_flush(ctx
);
608 buffer_write_byte(ctx
, 0x81);
609 buffer_add_read(ctx
, data
, 0, 8, 0);
612 void mpsse_read_data_bits_high_byte(struct mpsse_ctx
*ctx
, uint8_t *data
)
616 if (ctx
->retval
!= ERROR_OK
) {
617 DEBUG_IO("Ignoring command due to previous error");
621 if (buffer_write_space(ctx
) < 1 || buffer_read_space(ctx
) < 1)
622 ctx
->retval
= mpsse_flush(ctx
);
624 buffer_write_byte(ctx
, 0x83);
625 buffer_add_read(ctx
, data
, 0, 8, 0);
628 static void single_byte_boolean_helper(struct mpsse_ctx
*ctx
, bool var
, uint8_t val_if_true
,
629 uint8_t val_if_false
)
631 if (ctx
->retval
!= ERROR_OK
) {
632 DEBUG_IO("Ignoring command due to previous error");
636 if (buffer_write_space(ctx
) < 1)
637 ctx
->retval
= mpsse_flush(ctx
);
639 buffer_write_byte(ctx
, var
? val_if_true
: val_if_false
);
642 void mpsse_loopback_config(struct mpsse_ctx
*ctx
, bool enable
)
644 LOG_DEBUG("%s", enable
? "on" : "off");
645 single_byte_boolean_helper(ctx
, enable
, 0x84, 0x85);
648 void mpsse_set_divisor(struct mpsse_ctx
*ctx
, uint16_t divisor
)
650 LOG_DEBUG("%d", divisor
);
652 if (ctx
->retval
!= ERROR_OK
) {
653 DEBUG_IO("Ignoring command due to previous error");
657 if (buffer_write_space(ctx
) < 3)
658 ctx
->retval
= mpsse_flush(ctx
);
660 buffer_write_byte(ctx
, 0x86);
661 buffer_write_byte(ctx
, divisor
& 0xff);
662 buffer_write_byte(ctx
, divisor
>> 8);
665 int mpsse_divide_by_5_config(struct mpsse_ctx
*ctx
, bool enable
)
667 if (!mpsse_is_high_speed(ctx
))
670 LOG_DEBUG("%s", enable
? "on" : "off");
671 single_byte_boolean_helper(ctx
, enable
, 0x8b, 0x8a);
676 int mpsse_rtck_config(struct mpsse_ctx
*ctx
, bool enable
)
678 if (!mpsse_is_high_speed(ctx
))
681 LOG_DEBUG("%s", enable
? "on" : "off");
682 single_byte_boolean_helper(ctx
, enable
, 0x96, 0x97);
687 int mpsse_set_frequency(struct mpsse_ctx
*ctx
, int frequency
)
689 LOG_DEBUG("target %d Hz", frequency
);
690 assert(frequency
>= 0);
694 return mpsse_rtck_config(ctx
, true);
696 mpsse_rtck_config(ctx
, false); /* just try */
698 if (frequency
> 60000000 / 2 / 65536 && mpsse_divide_by_5_config(ctx
, false) == ERROR_OK
) {
699 base_clock
= 60000000;
701 mpsse_divide_by_5_config(ctx
, true); /* just try */
702 base_clock
= 12000000;
705 int divisor
= (base_clock
/ 2 + frequency
- 1) / frequency
- 1;
708 assert(divisor
>= 0);
710 mpsse_set_divisor(ctx
, divisor
);
712 frequency
= base_clock
/ 2 / (1 + divisor
);
713 LOG_DEBUG("actually %d Hz", frequency
);
718 /* Context needed by the callbacks */
719 struct transfer_result
{
720 struct mpsse_ctx
*ctx
;
722 unsigned transferred
;
725 static LIBUSB_CALL
void read_cb(struct libusb_transfer
*transfer
)
727 struct transfer_result
*res
= transfer
->user_data
;
728 struct mpsse_ctx
*ctx
= res
->ctx
;
730 unsigned packet_size
= ctx
->max_packet_size
;
732 DEBUG_PRINT_BUF(transfer
->buffer
, transfer
->actual_length
);
734 /* Strip the two status bytes sent at the beginning of each USB packet
735 * while copying the chunk buffer to the read buffer */
736 unsigned num_packets
= DIV_ROUND_UP(transfer
->actual_length
, packet_size
);
737 unsigned chunk_remains
= transfer
->actual_length
;
738 for (unsigned i
= 0; i
< num_packets
&& chunk_remains
> 2; i
++) {
739 unsigned this_size
= packet_size
- 2;
740 if (this_size
> chunk_remains
- 2)
741 this_size
= chunk_remains
- 2;
742 if (this_size
> ctx
->read_count
- res
->transferred
)
743 this_size
= ctx
->read_count
- res
->transferred
;
744 memcpy(ctx
->read_buffer
+ res
->transferred
,
745 ctx
->read_chunk
+ packet_size
* i
+ 2,
747 res
->transferred
+= this_size
;
748 chunk_remains
-= this_size
+ 2;
749 if (res
->transferred
== ctx
->read_count
) {
755 DEBUG_IO("raw chunk %d, transferred %d of %d", transfer
->actual_length
, res
->transferred
,
759 if (libusb_submit_transfer(transfer
) != LIBUSB_SUCCESS
)
763 static LIBUSB_CALL
void write_cb(struct libusb_transfer
*transfer
)
765 struct transfer_result
*res
= transfer
->user_data
;
766 struct mpsse_ctx
*ctx
= res
->ctx
;
768 res
->transferred
+= transfer
->actual_length
;
770 DEBUG_IO("transferred %d of %d", res
->transferred
, ctx
->write_count
);
772 DEBUG_PRINT_BUF(transfer
->buffer
, transfer
->actual_length
);
774 if (res
->transferred
== ctx
->write_count
)
777 transfer
->length
= ctx
->write_count
- res
->transferred
;
778 transfer
->buffer
= ctx
->write_buffer
+ res
->transferred
;
779 if (libusb_submit_transfer(transfer
) != LIBUSB_SUCCESS
)
784 int mpsse_flush(struct mpsse_ctx
*ctx
)
786 int retval
= ctx
->retval
;
788 if (retval
!= ERROR_OK
) {
789 DEBUG_IO("Ignoring flush due to previous error");
790 assert(ctx
->write_count
== 0 && ctx
->read_count
== 0);
791 ctx
->retval
= ERROR_OK
;
795 DEBUG_IO("write %d%s, read %d", ctx
->write_count
, ctx
->read_count
? "+1" : "",
797 assert(ctx
->write_count
> 0 || ctx
->read_count
== 0); /* No read data without write data */
799 if (ctx
->write_count
== 0)
802 struct libusb_transfer
*read_transfer
= 0;
803 struct transfer_result read_result
= { .ctx
= ctx
, .done
= true };
804 if (ctx
->read_count
) {
805 buffer_write_byte(ctx
, 0x87); /* SEND_IMMEDIATE */
806 read_result
.done
= false;
807 /* delay read transaction to ensure the FTDI chip can support us with data
808 immediately after processing the MPSSE commands in the write transaction */
811 struct transfer_result write_result
= { .ctx
= ctx
, .done
= false };
812 struct libusb_transfer
*write_transfer
= libusb_alloc_transfer(0);
813 libusb_fill_bulk_transfer(write_transfer
, ctx
->usb_dev
, ctx
->out_ep
, ctx
->write_buffer
,
814 ctx
->write_count
, write_cb
, &write_result
, ctx
->usb_write_timeout
);
815 retval
= libusb_submit_transfer(write_transfer
);
817 if (ctx
->read_count
) {
818 read_transfer
= libusb_alloc_transfer(0);
819 libusb_fill_bulk_transfer(read_transfer
, ctx
->usb_dev
, ctx
->in_ep
, ctx
->read_chunk
,
820 ctx
->read_chunk_size
, read_cb
, &read_result
,
821 ctx
->usb_read_timeout
);
822 retval
= libusb_submit_transfer(read_transfer
);
825 /* Polling loop, more or less taken from libftdi */
826 while (!write_result
.done
|| !read_result
.done
) {
827 retval
= libusb_handle_events(ctx
->usb_ctx
);
829 if (retval
!= LIBUSB_SUCCESS
&& retval
!= LIBUSB_ERROR_INTERRUPTED
) {
830 libusb_cancel_transfer(write_transfer
);
832 libusb_cancel_transfer(read_transfer
);
833 while (!write_result
.done
|| !read_result
.done
)
834 if (libusb_handle_events(ctx
->usb_ctx
) != LIBUSB_SUCCESS
)
839 if (retval
!= LIBUSB_SUCCESS
) {
840 LOG_ERROR("libusb_handle_events() failed with %d", retval
);
842 } else if (write_result
.transferred
< ctx
->write_count
) {
843 LOG_ERROR("ftdi device did not accept all data: %d, tried %d",
844 write_result
.transferred
,
847 } else if (read_result
.transferred
< ctx
->read_count
) {
848 LOG_ERROR("ftdi device did not return all data: %d, expected %d",
849 read_result
.transferred
,
852 } else if (ctx
->read_count
) {
853 ctx
->write_count
= 0;
855 bit_copy_execute(&ctx
->read_queue
);
858 ctx
->write_count
= 0;
859 bit_copy_discard(&ctx
->read_queue
);
863 libusb_free_transfer(write_transfer
);
865 libusb_free_transfer(read_transfer
);
867 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)