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, see <http://www.gnu.org/licenses/>. *
17 ***************************************************************************/
24 #include "helper/log.h"
25 #include "helper/time_support.h"
28 /* Compatibility define for older libusb-1.0 */
33 #define DEBUG_PRINT_BUF(buf, len) \
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); \
45 if (buf_string_pos > 0) \
46 LOG_DEBUG_IO("%s", buf_string);\
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)
53 #define BITMODE_MPSSE 0x02
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
60 #define SIO_RESET_SIO 0
61 #define SIO_RESET_PURGE_RX 1
62 #define SIO_RESET_PURGE_TX 2
65 libusb_context
*usb_ctx
;
66 libusb_device_handle
*usb_dev
;
67 unsigned int usb_write_timeout
;
68 unsigned int usb_read_timeout
;
71 uint16_t max_packet_size
;
74 enum ftdi_chip_type type
;
75 uint8_t *write_buffer
;
82 unsigned read_chunk_size
;
83 struct bit_copy_queue read_queue
;
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
,
92 char desc_string
[256]; /* Max size of string descriptor */
93 retval
= libusb_get_string_descriptor_ascii(device
, str_index
, (unsigned char *)desc_string
,
96 LOG_ERROR("libusb_get_string_descriptor_ascii() failed with %s", libusb_error_name(retval
));
99 return strncmp(string
, desc_string
, sizeof(desc_string
)) == 0;
102 static bool device_location_equal(libusb_device
*device
, const char *location
)
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
);
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)");
118 LOG_DEBUG("device path has %i steps", path_len
);
120 ptr
= strtok(loc
, "-:");
122 LOG_DEBUG("no ':' in path");
125 if (atoi(ptr
) != dev_bus
) {
126 LOG_DEBUG("bus mismatch");
131 while (path_step
< 7) {
132 ptr
= strtok(NULL
, ".,");
134 LOG_DEBUG("no more tokens in path at step %i", path_step
);
138 if (path_step
< path_len
139 && atoi(ptr
) != port_path
[path_step
]) {
140 LOG_DEBUG("path mismatch at step %i", path_step
);
147 /* walked the full path, all elements match */
148 if (path_step
== path_len
)
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
)
164 libusb_device
**list
;
165 struct libusb_device_descriptor desc
;
166 struct libusb_config_descriptor
*config0
;
169 ssize_t cnt
= libusb_get_device_list(ctx
->usb_ctx
, &list
);
171 LOG_ERROR("libusb_get_device_list() failed with %s", libusb_error_name(cnt
));
173 for (ssize_t i
= 0; i
< cnt
; i
++) {
174 libusb_device
*device
= list
[i
];
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
));
182 if (vid
&& *vid
!= desc
.idVendor
)
184 if (pid
&& *pid
!= desc
.idProduct
)
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
));
194 if (location
&& !device_location_equal(device
, location
)) {
195 libusb_close(ctx
->usb_dev
);
199 if (product
&& !string_descriptor_equal(ctx
->usb_dev
, desc
.iProduct
, product
)) {
200 libusb_close(ctx
->usb_dev
);
204 if (serial
&& !string_descriptor_equal(ctx
->usb_dev
, desc
.iSerialNumber
, serial
)) {
205 libusb_close(ctx
->usb_dev
);
213 libusb_free_device_list(list
, 1);
216 LOG_ERROR("no device found");
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
);
227 /* Make sure the first configuration is selected */
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
));
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
));
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
));
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
));
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
);
262 LOG_ERROR("failed to reset FTDI device: %s", libusb_error_name(err
));
266 switch (desc
.bcdDevice
) {
268 ctx
->type
= TYPE_FT2232C
;
271 ctx
->type
= TYPE_FT2232H
;
274 ctx
->type
= TYPE_FT4232H
;
277 ctx
->type
= TYPE_FT232H
;
280 LOG_ERROR("unsupported FTDI chip type: 0x%04x", desc
.bcdDevice
);
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))
289 const struct libusb_interface_descriptor
*descriptor
;
290 descriptor
= &config0
->interface
[ctx
->interface
].altsetting
[0];
291 if (descriptor
->bNumEndpoints
!= 2)
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
;
302 ctx
->out_ep
= descriptor
->endpoint
[i
].bEndpointAddress
;
306 if (ctx
->in_ep
== 0 || ctx
->out_ep
== 0)
309 libusb_free_config_descriptor(config0
);
313 LOG_ERROR("unrecognized USB device descriptor");
315 libusb_free_config_descriptor(config0
);
316 libusb_close(ctx
->usb_dev
);
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
)
323 struct mpsse_ctx
*ctx
= calloc(1, sizeof(*ctx
));
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
);
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
);
342 if (!ctx
->read_chunk
|| !ctx
->read_buffer
|| !ctx
->write_buffer
)
345 ctx
->interface
= channel
;
346 ctx
->index
= channel
+ 1;
347 ctx
->usb_read_timeout
= 5000;
348 ctx
->usb_write_timeout
= 5000;
350 err
= libusb_init(&ctx
->usb_ctx
);
351 if (err
!= LIBUSB_SUCCESS
) {
352 LOG_ERROR("libusb_init() failed with %s", libusb_error_name(err
));
356 if (!open_matching_device(ctx
, vid
, pid
, description
, serial
, location
)) {
357 /* Four hex digits plus terminating zero each */
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
: "*");
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
);
375 LOG_ERROR("unable to set latency timer: %s", libusb_error_name(err
));
379 err
= libusb_control_transfer(ctx
->usb_dev
,
380 FTDI_DEVICE_OUT_REQTYPE
,
381 SIO_SET_BITMODE_REQUEST
,
382 0x0b | (BITMODE_MPSSE
<< 8),
386 ctx
->usb_write_timeout
);
388 LOG_ERROR("unable to set MPSSE bitmode: %s", libusb_error_name(err
));
400 void mpsse_close(struct mpsse_ctx
*ctx
)
403 libusb_close(ctx
->usb_dev
);
405 libusb_exit(ctx
->usb_ctx
);
406 bit_copy_discard(&ctx
->read_queue
);
407 if (ctx
->write_buffer
)
408 free(ctx
->write_buffer
);
409 if (ctx
->read_buffer
)
410 free(ctx
->read_buffer
);
412 free(ctx
->read_chunk
);
417 bool mpsse_is_high_speed(struct mpsse_ctx
*ctx
)
419 return ctx
->type
!= TYPE_FT2232C
;
422 void mpsse_purge(struct mpsse_ctx
*ctx
)
426 ctx
->write_count
= 0;
428 ctx
->retval
= ERROR_OK
;
429 bit_copy_discard(&ctx
->read_queue
);
430 err
= libusb_control_transfer(ctx
->usb_dev
, FTDI_DEVICE_OUT_REQTYPE
, SIO_RESET_REQUEST
,
431 SIO_RESET_PURGE_RX
, ctx
->index
, NULL
, 0, ctx
->usb_write_timeout
);
433 LOG_ERROR("unable to purge ftdi rx buffers: %s", libusb_error_name(err
));
437 err
= libusb_control_transfer(ctx
->usb_dev
, FTDI_DEVICE_OUT_REQTYPE
, SIO_RESET_REQUEST
,
438 SIO_RESET_PURGE_TX
, ctx
->index
, NULL
, 0, ctx
->usb_write_timeout
);
440 LOG_ERROR("unable to purge ftdi tx buffers: %s", libusb_error_name(err
));
445 static unsigned buffer_write_space(struct mpsse_ctx
*ctx
)
447 /* Reserve one byte for SEND_IMMEDIATE */
448 return ctx
->write_size
- ctx
->write_count
- 1;
451 static unsigned buffer_read_space(struct mpsse_ctx
*ctx
)
453 return ctx
->read_size
- ctx
->read_count
;
456 static void buffer_write_byte(struct mpsse_ctx
*ctx
, uint8_t data
)
458 LOG_DEBUG_IO("%02x", data
);
459 assert(ctx
->write_count
< ctx
->write_size
);
460 ctx
->write_buffer
[ctx
->write_count
++] = data
;
463 static unsigned buffer_write(struct mpsse_ctx
*ctx
, const uint8_t *out
, unsigned out_offset
,
466 LOG_DEBUG_IO("%d bits", bit_count
);
467 assert(ctx
->write_count
+ DIV_ROUND_UP(bit_count
, 8) <= ctx
->write_size
);
468 bit_copy(ctx
->write_buffer
+ ctx
->write_count
, 0, out
, out_offset
, bit_count
);
469 ctx
->write_count
+= DIV_ROUND_UP(bit_count
, 8);
473 static unsigned buffer_add_read(struct mpsse_ctx
*ctx
, uint8_t *in
, unsigned in_offset
,
474 unsigned bit_count
, unsigned offset
)
476 LOG_DEBUG_IO("%d bits, offset %d", bit_count
, offset
);
477 assert(ctx
->read_count
+ DIV_ROUND_UP(bit_count
, 8) <= ctx
->read_size
);
478 bit_copy_queued(&ctx
->read_queue
, in
, in_offset
, ctx
->read_buffer
+ ctx
->read_count
, offset
,
480 ctx
->read_count
+= DIV_ROUND_UP(bit_count
, 8);
484 void mpsse_clock_data_out(struct mpsse_ctx
*ctx
, const uint8_t *out
, unsigned out_offset
,
485 unsigned length
, uint8_t mode
)
487 mpsse_clock_data(ctx
, out
, out_offset
, 0, 0, length
, mode
);
490 void mpsse_clock_data_in(struct mpsse_ctx
*ctx
, uint8_t *in
, unsigned in_offset
, unsigned length
,
493 mpsse_clock_data(ctx
, 0, 0, in
, in_offset
, length
, mode
);
496 void mpsse_clock_data(struct mpsse_ctx
*ctx
, const uint8_t *out
, unsigned out_offset
, uint8_t *in
,
497 unsigned in_offset
, unsigned length
, uint8_t mode
)
499 /* TODO: Fix MSB first modes */
500 LOG_DEBUG_IO("%s%s %d bits", in
? "in" : "", out
? "out" : "", length
);
502 if (ctx
->retval
!= ERROR_OK
) {
503 LOG_DEBUG_IO("Ignoring command due to previous error");
507 /* TODO: On H chips, use command 0x8E/0x8F if in and out are both 0 */
508 if (out
|| (!out
&& !in
))
514 /* Guarantee buffer space enough for a minimum size transfer */
515 if (buffer_write_space(ctx
) + (length
< 8) < (out
|| (!out
&& !in
) ? 4 : 3)
516 || (in
&& buffer_read_space(ctx
) < 1))
517 ctx
->retval
= mpsse_flush(ctx
);
520 /* Transfer remaining bits in bit mode */
521 buffer_write_byte(ctx
, 0x02 | mode
);
522 buffer_write_byte(ctx
, length
- 1);
524 out_offset
+= buffer_write(ctx
, out
, out_offset
, length
);
526 in_offset
+= buffer_add_read(ctx
, in
, in_offset
, length
, 8 - length
);
528 buffer_write_byte(ctx
, 0x00);
532 unsigned this_bytes
= length
/ 8;
533 /* MPSSE command limit */
534 if (this_bytes
> 65536)
536 /* Buffer space limit. We already made sure there's space for the minimum
538 if ((out
|| (!out
&& !in
)) && this_bytes
+ 3 > buffer_write_space(ctx
))
539 this_bytes
= buffer_write_space(ctx
) - 3;
540 if (in
&& this_bytes
> buffer_read_space(ctx
))
541 this_bytes
= buffer_read_space(ctx
);
543 if (this_bytes
> 0) {
544 buffer_write_byte(ctx
, mode
);
545 buffer_write_byte(ctx
, (this_bytes
- 1) & 0xff);
546 buffer_write_byte(ctx
, (this_bytes
- 1) >> 8);
548 out_offset
+= buffer_write(ctx
,
553 in_offset
+= buffer_add_read(ctx
,
559 for (unsigned n
= 0; n
< this_bytes
; n
++)
560 buffer_write_byte(ctx
, 0x00);
561 length
-= this_bytes
* 8;
567 void mpsse_clock_tms_cs_out(struct mpsse_ctx
*ctx
, const uint8_t *out
, unsigned out_offset
,
568 unsigned length
, bool tdi
, uint8_t mode
)
570 mpsse_clock_tms_cs(ctx
, out
, out_offset
, 0, 0, length
, tdi
, mode
);
573 void mpsse_clock_tms_cs(struct mpsse_ctx
*ctx
, const uint8_t *out
, unsigned out_offset
, uint8_t *in
,
574 unsigned in_offset
, unsigned length
, bool tdi
, uint8_t mode
)
576 LOG_DEBUG_IO("%sout %d bits, tdi=%d", in
? "in" : "", length
, tdi
);
579 if (ctx
->retval
!= ERROR_OK
) {
580 LOG_DEBUG_IO("Ignoring command due to previous error");
589 /* Guarantee buffer space enough for a minimum size transfer */
590 if (buffer_write_space(ctx
) < 3 || (in
&& buffer_read_space(ctx
) < 1))
591 ctx
->retval
= mpsse_flush(ctx
);
594 unsigned this_bits
= length
;
595 /* MPSSE command limit */
596 /* NOTE: there's a report of an FT2232 bug in this area, where shifting
597 * exactly 7 bits can make problems with TMS signaling for the last
600 * http://developer.intra2net.com/mailarchive/html/libftdi/2009/msg00292.html
606 buffer_write_byte(ctx
, mode
);
607 buffer_write_byte(ctx
, this_bits
- 1);
609 /* TODO: Fix MSB first, if allowed in MPSSE */
610 bit_copy(&data
, 0, out
, out_offset
, this_bits
);
611 out_offset
+= this_bits
;
612 buffer_write_byte(ctx
, data
| (tdi
? 0x80 : 0x00));
614 in_offset
+= buffer_add_read(ctx
,
624 void mpsse_set_data_bits_low_byte(struct mpsse_ctx
*ctx
, uint8_t data
, uint8_t dir
)
628 if (ctx
->retval
!= ERROR_OK
) {
629 LOG_DEBUG_IO("Ignoring command due to previous error");
633 if (buffer_write_space(ctx
) < 3)
634 ctx
->retval
= mpsse_flush(ctx
);
636 buffer_write_byte(ctx
, 0x80);
637 buffer_write_byte(ctx
, data
);
638 buffer_write_byte(ctx
, dir
);
641 void mpsse_set_data_bits_high_byte(struct mpsse_ctx
*ctx
, uint8_t data
, uint8_t dir
)
645 if (ctx
->retval
!= ERROR_OK
) {
646 LOG_DEBUG_IO("Ignoring command due to previous error");
650 if (buffer_write_space(ctx
) < 3)
651 ctx
->retval
= mpsse_flush(ctx
);
653 buffer_write_byte(ctx
, 0x82);
654 buffer_write_byte(ctx
, data
);
655 buffer_write_byte(ctx
, dir
);
658 void mpsse_read_data_bits_low_byte(struct mpsse_ctx
*ctx
, uint8_t *data
)
662 if (ctx
->retval
!= ERROR_OK
) {
663 LOG_DEBUG_IO("Ignoring command due to previous error");
667 if (buffer_write_space(ctx
) < 1 || buffer_read_space(ctx
) < 1)
668 ctx
->retval
= mpsse_flush(ctx
);
670 buffer_write_byte(ctx
, 0x81);
671 buffer_add_read(ctx
, data
, 0, 8, 0);
674 void mpsse_read_data_bits_high_byte(struct mpsse_ctx
*ctx
, uint8_t *data
)
678 if (ctx
->retval
!= ERROR_OK
) {
679 LOG_DEBUG_IO("Ignoring command due to previous error");
683 if (buffer_write_space(ctx
) < 1 || buffer_read_space(ctx
) < 1)
684 ctx
->retval
= mpsse_flush(ctx
);
686 buffer_write_byte(ctx
, 0x83);
687 buffer_add_read(ctx
, data
, 0, 8, 0);
690 static void single_byte_boolean_helper(struct mpsse_ctx
*ctx
, bool var
, uint8_t val_if_true
,
691 uint8_t val_if_false
)
693 if (ctx
->retval
!= ERROR_OK
) {
694 LOG_DEBUG_IO("Ignoring command due to previous error");
698 if (buffer_write_space(ctx
) < 1)
699 ctx
->retval
= mpsse_flush(ctx
);
701 buffer_write_byte(ctx
, var
? val_if_true
: val_if_false
);
704 void mpsse_loopback_config(struct mpsse_ctx
*ctx
, bool enable
)
706 LOG_DEBUG("%s", enable
? "on" : "off");
707 single_byte_boolean_helper(ctx
, enable
, 0x84, 0x85);
710 void mpsse_set_divisor(struct mpsse_ctx
*ctx
, uint16_t divisor
)
712 LOG_DEBUG("%d", divisor
);
714 if (ctx
->retval
!= ERROR_OK
) {
715 LOG_DEBUG_IO("Ignoring command due to previous error");
719 if (buffer_write_space(ctx
) < 3)
720 ctx
->retval
= mpsse_flush(ctx
);
722 buffer_write_byte(ctx
, 0x86);
723 buffer_write_byte(ctx
, divisor
& 0xff);
724 buffer_write_byte(ctx
, divisor
>> 8);
727 int mpsse_divide_by_5_config(struct mpsse_ctx
*ctx
, bool enable
)
729 if (!mpsse_is_high_speed(ctx
))
732 LOG_DEBUG("%s", enable
? "on" : "off");
733 single_byte_boolean_helper(ctx
, enable
, 0x8b, 0x8a);
738 int mpsse_rtck_config(struct mpsse_ctx
*ctx
, bool enable
)
740 if (!mpsse_is_high_speed(ctx
))
743 LOG_DEBUG("%s", enable
? "on" : "off");
744 single_byte_boolean_helper(ctx
, enable
, 0x96, 0x97);
749 int mpsse_set_frequency(struct mpsse_ctx
*ctx
, int frequency
)
751 LOG_DEBUG("target %d Hz", frequency
);
752 assert(frequency
>= 0);
756 return mpsse_rtck_config(ctx
, true);
758 mpsse_rtck_config(ctx
, false); /* just try */
760 if (frequency
> 60000000 / 2 / 65536 && mpsse_divide_by_5_config(ctx
, false) == ERROR_OK
) {
761 base_clock
= 60000000;
763 mpsse_divide_by_5_config(ctx
, true); /* just try */
764 base_clock
= 12000000;
767 int divisor
= (base_clock
/ 2 + frequency
- 1) / frequency
- 1;
770 assert(divisor
>= 0);
772 mpsse_set_divisor(ctx
, divisor
);
774 frequency
= base_clock
/ 2 / (1 + divisor
);
775 LOG_DEBUG("actually %d Hz", frequency
);
780 /* Context needed by the callbacks */
781 struct transfer_result
{
782 struct mpsse_ctx
*ctx
;
784 unsigned transferred
;
787 static LIBUSB_CALL
void read_cb(struct libusb_transfer
*transfer
)
789 struct transfer_result
*res
= transfer
->user_data
;
790 struct mpsse_ctx
*ctx
= res
->ctx
;
792 unsigned packet_size
= ctx
->max_packet_size
;
794 DEBUG_PRINT_BUF(transfer
->buffer
, transfer
->actual_length
);
796 /* Strip the two status bytes sent at the beginning of each USB packet
797 * while copying the chunk buffer to the read buffer */
798 unsigned num_packets
= DIV_ROUND_UP(transfer
->actual_length
, packet_size
);
799 unsigned chunk_remains
= transfer
->actual_length
;
800 for (unsigned i
= 0; i
< num_packets
&& chunk_remains
> 2; i
++) {
801 unsigned this_size
= packet_size
- 2;
802 if (this_size
> chunk_remains
- 2)
803 this_size
= chunk_remains
- 2;
804 if (this_size
> ctx
->read_count
- res
->transferred
)
805 this_size
= ctx
->read_count
- res
->transferred
;
806 memcpy(ctx
->read_buffer
+ res
->transferred
,
807 ctx
->read_chunk
+ packet_size
* i
+ 2,
809 res
->transferred
+= this_size
;
810 chunk_remains
-= this_size
+ 2;
811 if (res
->transferred
== ctx
->read_count
) {
817 LOG_DEBUG_IO("raw chunk %d, transferred %d of %d", transfer
->actual_length
, res
->transferred
,
821 if (libusb_submit_transfer(transfer
) != LIBUSB_SUCCESS
)
825 static LIBUSB_CALL
void write_cb(struct libusb_transfer
*transfer
)
827 struct transfer_result
*res
= transfer
->user_data
;
828 struct mpsse_ctx
*ctx
= res
->ctx
;
830 res
->transferred
+= transfer
->actual_length
;
832 LOG_DEBUG_IO("transferred %d of %d", res
->transferred
, ctx
->write_count
);
834 DEBUG_PRINT_BUF(transfer
->buffer
, transfer
->actual_length
);
836 if (res
->transferred
== ctx
->write_count
)
839 transfer
->length
= ctx
->write_count
- res
->transferred
;
840 transfer
->buffer
= ctx
->write_buffer
+ res
->transferred
;
841 if (libusb_submit_transfer(transfer
) != LIBUSB_SUCCESS
)
846 int mpsse_flush(struct mpsse_ctx
*ctx
)
848 int retval
= ctx
->retval
;
850 if (retval
!= ERROR_OK
) {
851 LOG_DEBUG_IO("Ignoring flush due to previous error");
852 assert(ctx
->write_count
== 0 && ctx
->read_count
== 0);
853 ctx
->retval
= ERROR_OK
;
857 LOG_DEBUG_IO("write %d%s, read %d", ctx
->write_count
, ctx
->read_count
? "+1" : "",
859 assert(ctx
->write_count
> 0 || ctx
->read_count
== 0); /* No read data without write data */
861 if (ctx
->write_count
== 0)
864 struct libusb_transfer
*read_transfer
= 0;
865 struct transfer_result read_result
= { .ctx
= ctx
, .done
= true };
866 if (ctx
->read_count
) {
867 buffer_write_byte(ctx
, 0x87); /* SEND_IMMEDIATE */
868 read_result
.done
= false;
869 /* delay read transaction to ensure the FTDI chip can support us with data
870 immediately after processing the MPSSE commands in the write transaction */
873 struct transfer_result write_result
= { .ctx
= ctx
, .done
= false };
874 struct libusb_transfer
*write_transfer
= libusb_alloc_transfer(0);
875 libusb_fill_bulk_transfer(write_transfer
, ctx
->usb_dev
, ctx
->out_ep
, ctx
->write_buffer
,
876 ctx
->write_count
, write_cb
, &write_result
, ctx
->usb_write_timeout
);
877 retval
= libusb_submit_transfer(write_transfer
);
878 if (retval
!= LIBUSB_SUCCESS
)
881 if (ctx
->read_count
) {
882 read_transfer
= libusb_alloc_transfer(0);
883 libusb_fill_bulk_transfer(read_transfer
, ctx
->usb_dev
, ctx
->in_ep
, ctx
->read_chunk
,
884 ctx
->read_chunk_size
, read_cb
, &read_result
,
885 ctx
->usb_read_timeout
);
886 retval
= libusb_submit_transfer(read_transfer
);
887 if (retval
!= LIBUSB_SUCCESS
)
891 /* Polling loop, more or less taken from libftdi */
892 int64_t start
= timeval_ms();
893 int64_t warn_after
= 2000;
894 while (!write_result
.done
|| !read_result
.done
) {
895 struct timeval timeout_usb
;
897 timeout_usb
.tv_sec
= 1;
898 timeout_usb
.tv_usec
= 0;
900 retval
= libusb_handle_events_timeout_completed(ctx
->usb_ctx
, &timeout_usb
, NULL
);
902 if (retval
== LIBUSB_ERROR_NO_DEVICE
|| retval
== LIBUSB_ERROR_INTERRUPTED
)
905 if (retval
!= LIBUSB_SUCCESS
) {
906 libusb_cancel_transfer(write_transfer
);
908 libusb_cancel_transfer(read_transfer
);
909 while (!write_result
.done
|| !read_result
.done
) {
910 retval
= libusb_handle_events_timeout_completed(ctx
->usb_ctx
,
912 if (retval
!= LIBUSB_SUCCESS
)
917 int64_t now
= timeval_ms();
918 if (now
- start
> warn_after
) {
919 LOG_WARNING("Haven't made progress in mpsse_flush() for %" PRId64
926 if (retval
!= LIBUSB_SUCCESS
) {
927 LOG_ERROR("libusb_handle_events() failed with %s", libusb_error_name(retval
));
929 } else if (write_result
.transferred
< ctx
->write_count
) {
930 LOG_ERROR("ftdi device did not accept all data: %d, tried %d",
931 write_result
.transferred
,
934 } else if (read_result
.transferred
< ctx
->read_count
) {
935 LOG_ERROR("ftdi device did not return all data: %d, expected %d",
936 read_result
.transferred
,
939 } else if (ctx
->read_count
) {
940 ctx
->write_count
= 0;
942 bit_copy_execute(&ctx
->read_queue
);
945 ctx
->write_count
= 0;
946 bit_copy_discard(&ctx
->read_queue
);
950 libusb_free_transfer(write_transfer
);
952 libusb_free_transfer(read_transfer
);
954 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)