1 /***************************************************************************
3 * Copyright (C) 2009 by Cahya Wirawan <cahya@gmx.at> *
4 * Based on opendous driver by Vladimir Fonov *
6 * Copyright (C) 2009 by Vladimir Fonov <vladimir.fonov@gmai.com> *
7 * Based on J-link driver by Juergen Stuber *
9 * Copyright (C) 2007 by Juergen Stuber <juergen@jstuber.net> *
10 * based on Dominic Rath's and Benedikt Sauter's usbprog.c *
12 * Copyright (C) 2008 by Spencer Oliver *
13 * spen@spen-soft.co.uk *
15 * This program is free software; you can redistribute it and/or modify *
16 * it under the terms of the GNU General Public License as published by *
17 * the Free Software Foundation; either version 2 of the License, or *
18 * (at your option) any later version. *
20 * This program is distributed in the hope that it will be useful, *
21 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
22 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
23 * GNU General Public License for more details. *
25 * You should have received a copy of the GNU General Public License *
26 * along with this program. If not, see <http://www.gnu.org/licenses/>. *
27 ***************************************************************************/
33 #include <jtag/interface.h>
34 #include <jtag/commands.h>
35 #include "libusb_helper.h"
39 #define OPENDOUS_MAX_VIDS_PIDS 4
40 /* define some probes with similar interface */
41 struct opendous_probe
{
43 uint16_t VID
[OPENDOUS_MAX_VIDS_PIDS
];
44 uint16_t PID
[OPENDOUS_MAX_VIDS_PIDS
];
47 uint8_t CONTROL_TRANSFER
;
51 static const struct opendous_probe opendous_probes
[] = {
52 {"usbprog-jtag", {0x1781, 0}, {0x0C63, 0}, 0x82, 0x02, 0x00, 510 },
53 {"opendous", {0x1781, 0x03EB, 0}, {0xC0C0, 0x204F, 0}, 0x81, 0x02, 0x00, 360 },
54 {"usbvlab", {0x16C0, 0}, {0x05DC, 0}, 0x81, 0x02, 0x01, 360 },
55 {NULL
, {0x0000}, {0x0000}, 0x00, 0x00, 0x00, 0 }
58 #define OPENDOUS_WRITE_ENDPOINT (opendous_probe->WRITE_EP)
59 #define OPENDOUS_READ_ENDPOINT (opendous_probe->READ_EP)
61 static unsigned int opendous_hw_jtag_version
= 1;
63 #define OPENDOUS_USB_TIMEOUT 1000
65 #define OPENDOUS_USB_BUFFER_SIZE (opendous_probe->BUFFERSIZE)
66 #define OPENDOUS_IN_BUFFER_SIZE (OPENDOUS_USB_BUFFER_SIZE)
67 #define OPENDOUS_OUT_BUFFER_SIZE (OPENDOUS_USB_BUFFER_SIZE)
69 /* Global USB buffers */
70 static uint8_t *usb_in_buffer
;
71 static uint8_t *usb_out_buffer
;
73 /* Constants for OPENDOUS command */
75 #define OPENDOUS_MAX_SPEED 66
76 #define OPENDOUS_MAX_TAP_TRANSMIT ((opendous_probe->BUFFERSIZE)-10)
77 #define OPENDOUS_MAX_INPUT_DATA (OPENDOUS_MAX_TAP_TRANSMIT*4)
80 #define OPENDOUS_TAP_BUFFER_SIZE 65536
82 struct pending_scan_result
{
83 int first
; /* First bit position in tdo_buffer to read */
84 int length
; /* Number of bits to read */
85 struct scan_command
*command
; /* Corresponding scan command */
89 static int pending_scan_results_length
;
90 static struct pending_scan_result
*pending_scan_results_buffer
;
92 #define MAX_PENDING_SCAN_RESULTS (OPENDOUS_MAX_INPUT_DATA)
94 /* JTAG usb commands */
95 #define JTAG_CMD_TAP_OUTPUT 0x0
96 #define JTAG_CMD_SET_TRST 0x1
97 #define JTAG_CMD_SET_SRST 0x2
98 #define JTAG_CMD_READ_INPUT 0x3
99 #define JTAG_CMD_TAP_OUTPUT_EMU 0x4
100 #define JTAG_CMD_SET_DELAY 0x5
101 #define JTAG_CMD_SET_SRST_TRST 0x6
102 #define JTAG_CMD_READ_CONFIG 0x7
104 /* usbvlab control transfer */
105 #define FUNC_START_BOOTLOADER 30
106 #define FUNC_WRITE_DATA 0x50
107 #define FUNC_READ_DATA 0x51
109 static char *opendous_type
;
110 static const struct opendous_probe
*opendous_probe
;
112 /* External interface functions */
113 static int opendous_execute_queue(void);
114 static int opendous_init(void);
115 static int opendous_quit(void);
117 /* Queue command functions */
118 static void opendous_end_state(tap_state_t state
);
119 static void opendous_state_move(void);
120 static void opendous_path_move(int num_states
, tap_state_t
*path
);
121 static void opendous_runtest(int num_cycles
);
122 static void opendous_scan(int ir_scan
, enum scan_type type
, uint8_t *buffer
,
123 int scan_size
, struct scan_command
*command
);
124 static void opendous_reset(int trst
, int srst
);
125 static void opendous_simple_command(uint8_t command
, uint8_t _data
);
126 static int opendous_get_status(void);
128 /* opendous tap buffer functions */
129 static void opendous_tap_init(void);
130 static int opendous_tap_execute(void);
131 static void opendous_tap_ensure_space(int scans
, int bits
);
132 static void opendous_tap_append_step(int tms
, int tdi
);
133 static void opendous_tap_append_scan(int length
, uint8_t *buffer
, struct scan_command
*command
);
135 /* opendous lowlevel functions */
136 struct opendous_jtag
{
137 struct libusb_device_handle
*usb_handle
;
140 static struct opendous_jtag
*opendous_usb_open(void);
141 static void opendous_usb_close(struct opendous_jtag
*opendous_jtag
);
142 static int opendous_usb_message(struct opendous_jtag
*opendous_jtag
, int out_length
, int in_length
);
143 static int opendous_usb_write(struct opendous_jtag
*opendous_jtag
, int out_length
);
144 static int opendous_usb_read(struct opendous_jtag
*opendous_jtag
);
146 /* helper functions */
147 int opendous_get_version_info(void);
149 #ifdef _DEBUG_USB_COMMS_
150 static void opendous_debug_buffer(uint8_t *buffer
, int length
);
153 static struct opendous_jtag
*opendous_jtag_handle
;
155 /***************************************************************************/
156 /* External interface implementation */
158 COMMAND_HANDLER(opendous_handle_opendous_type_command
)
163 /* only if the cable name wasn't overwritten by cmdline */
164 if (opendous_type
== NULL
) {
165 /* REVISIT first verify that it's listed in cables[] ... */
166 opendous_type
= strdup(CMD_ARGV
[0]);
169 /* REVISIT it's probably worth returning the current value ... */
174 COMMAND_HANDLER(opendous_handle_opendous_info_command
)
176 if (opendous_get_version_info() == ERROR_OK
) {
177 /* attempt to get status */
178 opendous_get_status();
184 COMMAND_HANDLER(opendous_handle_opendous_hw_jtag_command
)
188 command_print(CMD
, "opendous hw jtag %i", opendous_hw_jtag_version
);
192 int request_version
= atoi(CMD_ARGV
[0]);
193 switch (request_version
) {
196 opendous_hw_jtag_version
= request_version
;
200 return ERROR_COMMAND_SYNTAX_ERROR
;
206 return ERROR_COMMAND_SYNTAX_ERROR
;
212 static const struct command_registration opendous_command_handlers
[] = {
214 .name
= "opendous_info",
215 .handler
= &opendous_handle_opendous_info_command
,
216 .mode
= COMMAND_EXEC
,
217 .help
= "show opendous info",
221 .name
= "opendous_hw_jtag",
222 .handler
= &opendous_handle_opendous_hw_jtag_command
,
223 .mode
= COMMAND_EXEC
,
224 .help
= "access opendous HW JTAG command version",
228 .name
= "opendous_type",
229 .handler
= &opendous_handle_opendous_type_command
,
230 .mode
= COMMAND_CONFIG
,
231 .help
= "set opendous type",
232 .usage
= "[usbvlab|usbprog-jtag|opendous]",
234 COMMAND_REGISTRATION_DONE
237 static struct jtag_interface opendous_interface
= {
238 .execute_queue
= opendous_execute_queue
,
241 struct adapter_driver opendous_adapter_driver
= {
243 .transports
= jtag_only
,
244 .commands
= opendous_command_handlers
,
246 .init
= opendous_init
,
247 .quit
= opendous_quit
,
249 .jtag_ops
= &opendous_interface
,
252 static int opendous_execute_queue(void)
254 struct jtag_command
*cmd
= jtag_command_queue
;
259 while (cmd
!= NULL
) {
262 LOG_DEBUG_IO("runtest %i cycles, end in %i", cmd
->cmd
.runtest
->num_cycles
,
263 cmd
->cmd
.runtest
->end_state
);
265 if (cmd
->cmd
.runtest
->end_state
!= -1)
266 opendous_end_state(cmd
->cmd
.runtest
->end_state
);
267 opendous_runtest(cmd
->cmd
.runtest
->num_cycles
);
271 LOG_DEBUG_IO("statemove end in %i", cmd
->cmd
.statemove
->end_state
);
273 if (cmd
->cmd
.statemove
->end_state
!= -1)
274 opendous_end_state(cmd
->cmd
.statemove
->end_state
);
275 opendous_state_move();
279 LOG_DEBUG_IO("pathmove: %i states, end in %i",
280 cmd
->cmd
.pathmove
->num_states
,
281 cmd
->cmd
.pathmove
->path
[cmd
->cmd
.pathmove
->num_states
- 1]);
283 opendous_path_move(cmd
->cmd
.pathmove
->num_states
, cmd
->cmd
.pathmove
->path
);
287 LOG_DEBUG_IO("scan end in %i", cmd
->cmd
.scan
->end_state
);
289 if (cmd
->cmd
.scan
->end_state
!= -1)
290 opendous_end_state(cmd
->cmd
.scan
->end_state
);
292 scan_size
= jtag_build_buffer(cmd
->cmd
.scan
, &buffer
);
293 LOG_DEBUG_IO("scan input, length = %d", scan_size
);
295 #ifdef _DEBUG_USB_COMMS_
296 opendous_debug_buffer(buffer
, (scan_size
+ 7) / 8);
298 type
= jtag_scan_type(cmd
->cmd
.scan
);
299 opendous_scan(cmd
->cmd
.scan
->ir_scan
, type
, buffer
, scan_size
, cmd
->cmd
.scan
);
303 LOG_DEBUG_IO("reset trst: %i srst %i", cmd
->cmd
.reset
->trst
, cmd
->cmd
.reset
->srst
);
305 opendous_tap_execute();
307 if (cmd
->cmd
.reset
->trst
== 1)
308 tap_set_state(TAP_RESET
);
309 opendous_reset(cmd
->cmd
.reset
->trst
, cmd
->cmd
.reset
->srst
);
313 LOG_DEBUG_IO("sleep %" PRIu32
, cmd
->cmd
.sleep
->us
);
314 opendous_tap_execute();
315 jtag_sleep(cmd
->cmd
.sleep
->us
);
319 LOG_ERROR("BUG: unknown JTAG command type encountered");
324 return opendous_tap_execute();
327 static int opendous_init(void)
330 const struct opendous_probe
*cur_opendous_probe
;
332 cur_opendous_probe
= opendous_probes
;
334 if (opendous_type
== NULL
) {
335 opendous_type
= strdup("opendous");
336 LOG_WARNING("No opendous_type specified, using default 'opendous'");
339 while (cur_opendous_probe
->name
) {
340 if (strcmp(cur_opendous_probe
->name
, opendous_type
) == 0) {
341 opendous_probe
= cur_opendous_probe
;
344 cur_opendous_probe
++;
347 if (!opendous_probe
) {
348 LOG_ERROR("No matching cable found for %s", opendous_type
);
349 return ERROR_JTAG_INIT_FAILED
;
353 usb_in_buffer
= malloc(opendous_probe
->BUFFERSIZE
);
354 usb_out_buffer
= malloc(opendous_probe
->BUFFERSIZE
);
356 pending_scan_results_buffer
= malloc(
357 MAX_PENDING_SCAN_RESULTS
* sizeof(*pending_scan_results_buffer
));
359 opendous_jtag_handle
= opendous_usb_open();
361 if (opendous_jtag_handle
== 0) {
362 LOG_ERROR("Cannot find opendous Interface! Please check connection and permissions.");
363 return ERROR_JTAG_INIT_FAILED
;
367 while (check_cnt
< 3) {
368 if (opendous_get_version_info() == ERROR_OK
) {
369 /* attempt to get status */
370 opendous_get_status();
377 LOG_INFO("opendous JTAG Interface ready");
379 opendous_reset(0, 0);
385 static int opendous_quit(void)
387 opendous_usb_close(opendous_jtag_handle
);
389 if (usb_out_buffer
) {
390 free(usb_out_buffer
);
391 usb_out_buffer
= NULL
;
396 usb_in_buffer
= NULL
;
399 if (pending_scan_results_buffer
) {
400 free(pending_scan_results_buffer
);
401 pending_scan_results_buffer
= NULL
;
406 opendous_type
= NULL
;
412 /***************************************************************************/
413 /* Queue command implementations */
415 void opendous_end_state(tap_state_t state
)
417 if (tap_is_state_stable(state
))
418 tap_set_end_state(state
);
420 LOG_ERROR("BUG: %i is not a valid end state", state
);
425 /* Goes to the end state. */
426 void opendous_state_move(void)
430 uint8_t tms_scan
= tap_get_tms_path(tap_get_state(), tap_get_end_state());
431 uint8_t tms_scan_bits
= tap_get_tms_path_len(tap_get_state(), tap_get_end_state());
433 for (i
= 0; i
< tms_scan_bits
; i
++) {
434 tms
= (tms_scan
>> i
) & 1;
435 opendous_tap_append_step(tms
, 0);
438 tap_set_state(tap_get_end_state());
441 void opendous_path_move(int num_states
, tap_state_t
*path
)
445 for (i
= 0; i
< num_states
; i
++) {
446 if (path
[i
] == tap_state_transition(tap_get_state(), false))
447 opendous_tap_append_step(0, 0);
448 else if (path
[i
] == tap_state_transition(tap_get_state(), true))
449 opendous_tap_append_step(1, 0);
451 LOG_ERROR("BUG: %s -> %s isn't a valid TAP transition",
452 tap_state_name(tap_get_state()), tap_state_name(path
[i
]));
456 tap_set_state(path
[i
]);
459 tap_set_end_state(tap_get_state());
462 void opendous_runtest(int num_cycles
)
466 tap_state_t saved_end_state
= tap_get_end_state();
468 /* only do a state_move when we're not already in IDLE */
469 if (tap_get_state() != TAP_IDLE
) {
470 opendous_end_state(TAP_IDLE
);
471 opendous_state_move();
474 /* execute num_cycles */
475 for (i
= 0; i
< num_cycles
; i
++)
476 opendous_tap_append_step(0, 0);
478 /* finish in end_state */
479 opendous_end_state(saved_end_state
);
480 if (tap_get_state() != tap_get_end_state())
481 opendous_state_move();
484 void opendous_scan(int ir_scan
, enum scan_type type
, uint8_t *buffer
, int scan_size
, struct scan_command
*command
)
486 tap_state_t saved_end_state
;
488 opendous_tap_ensure_space(1, scan_size
+ 8);
490 saved_end_state
= tap_get_end_state();
492 /* Move to appropriate scan state */
493 opendous_end_state(ir_scan
? TAP_IRSHIFT
: TAP_DRSHIFT
);
495 if (tap_get_state() != tap_get_end_state())
496 opendous_state_move();
498 opendous_end_state(saved_end_state
);
501 opendous_tap_append_scan(scan_size
, buffer
, command
);
503 /* We are in Exit1, go to Pause */
504 opendous_tap_append_step(0, 0);
506 tap_set_state(ir_scan
? TAP_IRPAUSE
: TAP_DRPAUSE
);
508 if (tap_get_state() != tap_get_end_state())
509 opendous_state_move();
512 void opendous_reset(int trst
, int srst
)
514 LOG_DEBUG("trst: %i, srst: %i", trst
, srst
);
516 /* Signals are active low */
519 opendous_simple_command(JTAG_CMD_SET_SRST
, 1);
521 opendous_simple_command(JTAG_CMD_SET_SRST
, 0);
524 opendous_simple_command(JTAG_CMD_SET_TRST
, 1);
526 opendous_simple_command(JTAG_CMD_SET_TRST
, 0);
531 opendous_simple_command(JTAG_CMD_SET_SRST_TRST
, srst
| trst
);
534 void opendous_simple_command(uint8_t command
, uint8_t _data
)
538 LOG_DEBUG_IO("0x%02x 0x%02x", command
, _data
);
540 usb_out_buffer
[0] = 2;
541 usb_out_buffer
[1] = 0;
542 usb_out_buffer
[2] = command
;
543 usb_out_buffer
[3] = _data
;
545 result
= opendous_usb_message(opendous_jtag_handle
, 4, 1);
547 LOG_ERROR("opendous command 0x%02x failed (%d)", command
, result
);
550 int opendous_get_status(void)
555 int opendous_get_version_info(void)
560 /***************************************************************************/
561 /* Estick tap functions */
563 static int tap_length
;
564 static uint8_t tms_buffer
[OPENDOUS_TAP_BUFFER_SIZE
];
565 static uint8_t tdo_buffer
[OPENDOUS_TAP_BUFFER_SIZE
];
569 void opendous_tap_init(void)
572 pending_scan_results_length
= 0;
575 void opendous_tap_ensure_space(int scans
, int bits
)
577 int available_scans
= MAX_PENDING_SCAN_RESULTS
- pending_scan_results_length
;
578 int available_bits
= OPENDOUS_TAP_BUFFER_SIZE
/ 2 - tap_length
;
580 if ((scans
> available_scans
) || (bits
> available_bits
))
581 opendous_tap_execute();
584 void opendous_tap_append_step(int tms
, int tdi
)
587 unsigned char _tms
= tms
? 1 : 0;
588 unsigned char _tdi
= tdi
? 1 : 0;
590 opendous_tap_ensure_space(0, 1);
592 int tap_index
= tap_length
/ 4;
593 int bits
= (tap_length
% 4) * 2;
595 if (tap_length
< OPENDOUS_TAP_BUFFER_SIZE
) {
597 tms_buffer
[tap_index
] = 0;
599 tms_buffer
[tap_index
] |= (_tdi
<< bits
)|(_tms
<< (bits
+ 1));
602 LOG_ERROR("opendous_tap_append_step, overflow");
605 void opendous_tap_append_scan(int length
, uint8_t *buffer
, struct scan_command
*command
)
607 LOG_DEBUG_IO("append scan, length = %d", length
);
609 struct pending_scan_result
*pending_scan_result
= &pending_scan_results_buffer
[pending_scan_results_length
];
612 pending_scan_result
->first
= tap_length
;
613 pending_scan_result
->length
= length
;
614 pending_scan_result
->command
= command
;
615 pending_scan_result
->buffer
= buffer
;
617 for (i
= 0; i
< length
; i
++)
618 opendous_tap_append_step((i
< length
-1 ? 0 : 1), (buffer
[i
/ 8] >> (i
% 8)) & 1);
619 pending_scan_results_length
++;
622 /* Pad and send a tap sequence to the device, and receive the answer.
623 * For the purpose of padding we assume that we are in idle or pause state. */
624 int opendous_tap_execute(void)
630 #ifdef _DEBUG_USB_COMMS_
634 if (tap_length
> 0) {
636 /* memset(tdo_buffer,0,OPENDOUS_TAP_BUFFER_SIZE); */
637 /* LOG_INFO("OPENDOUS tap execute %d",tap_length); */
638 byte_length
= (tap_length
+ 3) / 4;
640 #ifdef _DEBUG_USB_COMMS_
641 byte_length_out
= (tap_length
+ 7) / 8;
642 LOG_DEBUG("opendous is sending %d bytes", byte_length
);
645 for (j
= 0, i
= 0; j
< byte_length
;) {
648 int transmit
= byte_length
- j
;
649 if (transmit
> OPENDOUS_MAX_TAP_TRANSMIT
) {
650 transmit
= OPENDOUS_MAX_TAP_TRANSMIT
;
651 receive
= (OPENDOUS_MAX_TAP_TRANSMIT
) / 2;
652 usb_out_buffer
[2] = JTAG_CMD_TAP_OUTPUT
;
654 usb_out_buffer
[2] = JTAG_CMD_TAP_OUTPUT
| ((tap_length
% 4) << 4);
655 receive
= (transmit
+ 1) / 2;
657 usb_out_buffer
[0] = (transmit
+ 1) & 0xff;
658 usb_out_buffer
[1] = ((transmit
+ 1) >> 8) & 0xff;
660 memmove(usb_out_buffer
+ 3, tms_buffer
+ j
, transmit
);
661 result
= opendous_usb_message(opendous_jtag_handle
, 3 + transmit
, receive
);
662 if (result
!= receive
) {
663 LOG_ERROR("opendous_tap_execute, wrong result %d, expected %d", result
, receive
);
664 return ERROR_JTAG_QUEUE_FAILED
;
667 memmove(tdo_buffer
+ i
, usb_in_buffer
, receive
);
672 #ifdef _DEBUG_USB_COMMS_
673 LOG_DEBUG("opendous tap result %d", byte_length_out
);
674 opendous_debug_buffer(tdo_buffer
, byte_length_out
);
677 /* LOG_INFO("eStick tap execute %d",tap_length); */
678 for (i
= 0; i
< pending_scan_results_length
; i
++) {
680 struct pending_scan_result
*pending_scan_result
= &pending_scan_results_buffer
[i
];
681 uint8_t *buffer
= pending_scan_result
->buffer
;
682 int length
= pending_scan_result
->length
;
683 int first
= pending_scan_result
->first
;
684 struct scan_command
*command
= pending_scan_result
->command
;
687 buf_set_buf(tdo_buffer
, first
, buffer
, 0, length
);
689 LOG_DEBUG_IO("pending scan result, length = %d", length
);
691 #ifdef _DEBUG_USB_COMMS_
692 opendous_debug_buffer(buffer
, byte_length_out
);
695 if (jtag_read_buffer(buffer
, command
) != ERROR_OK
) {
697 return ERROR_JTAG_QUEUE_FAILED
;
700 if (pending_scan_result
->buffer
!= NULL
)
701 free(pending_scan_result
->buffer
);
710 /*****************************************************************************/
711 /* Estick USB low-level functions */
713 struct opendous_jtag
*opendous_usb_open(void)
715 struct opendous_jtag
*result
;
717 struct libusb_device_handle
*devh
;
718 if (jtag_libusb_open(opendous_probe
->VID
, opendous_probe
->PID
, NULL
, &devh
, NULL
) != ERROR_OK
)
721 jtag_libusb_set_configuration(devh
, 0);
722 libusb_claim_interface(devh
, 0);
724 result
= malloc(sizeof(*result
));
725 result
->usb_handle
= devh
;
729 void opendous_usb_close(struct opendous_jtag
*opendous_jtag
)
731 jtag_libusb_close(opendous_jtag
->usb_handle
);
735 /* Send a message and receive the reply. */
736 int opendous_usb_message(struct opendous_jtag
*opendous_jtag
, int out_length
, int in_length
)
740 result
= opendous_usb_write(opendous_jtag
, out_length
);
741 if (result
== out_length
) {
742 result
= opendous_usb_read(opendous_jtag
);
743 if (result
== in_length
)
746 LOG_ERROR("usb_bulk_read failed (requested=%d, result=%d)", in_length
, result
);
750 LOG_ERROR("usb_bulk_write failed (requested=%d, result=%d)", out_length
, result
);
755 /* Write data from out_buffer to USB. */
756 int opendous_usb_write(struct opendous_jtag
*opendous_jtag
, int out_length
)
760 if (out_length
> OPENDOUS_OUT_BUFFER_SIZE
) {
761 LOG_ERROR("opendous_jtag_write illegal out_length=%d (max=%d)", out_length
, OPENDOUS_OUT_BUFFER_SIZE
);
765 #ifdef _DEBUG_USB_COMMS_
766 LOG_DEBUG("USB write begin");
768 if (opendous_probe
->CONTROL_TRANSFER
) {
769 result
= jtag_libusb_control_transfer(opendous_jtag
->usb_handle
,
770 LIBUSB_REQUEST_TYPE_VENDOR
| LIBUSB_RECIPIENT_DEVICE
| LIBUSB_ENDPOINT_OUT
,
771 FUNC_WRITE_DATA
, 0, 0, (char *) usb_out_buffer
, out_length
, OPENDOUS_USB_TIMEOUT
);
773 jtag_libusb_bulk_write(opendous_jtag
->usb_handle
, OPENDOUS_WRITE_ENDPOINT
,
774 (char *)usb_out_buffer
, out_length
, OPENDOUS_USB_TIMEOUT
, &result
);
776 #ifdef _DEBUG_USB_COMMS_
777 LOG_DEBUG("USB write end: %d bytes", result
);
780 LOG_DEBUG_IO("opendous_usb_write, out_length = %d, result = %d", out_length
, result
);
782 #ifdef _DEBUG_USB_COMMS_
783 opendous_debug_buffer(usb_out_buffer
, out_length
);
788 /* Read data from USB into in_buffer. */
789 int opendous_usb_read(struct opendous_jtag
*opendous_jtag
)
791 #ifdef _DEBUG_USB_COMMS_
792 LOG_DEBUG("USB read begin");
795 if (opendous_probe
->CONTROL_TRANSFER
) {
796 result
= jtag_libusb_control_transfer(opendous_jtag
->usb_handle
,
797 LIBUSB_REQUEST_TYPE_VENDOR
| LIBUSB_RECIPIENT_DEVICE
| LIBUSB_ENDPOINT_IN
,
798 FUNC_READ_DATA
, 0, 0, (char *) usb_in_buffer
, OPENDOUS_IN_BUFFER_SIZE
, OPENDOUS_USB_TIMEOUT
);
800 jtag_libusb_bulk_read(opendous_jtag
->usb_handle
, OPENDOUS_READ_ENDPOINT
,
801 (char *)usb_in_buffer
, OPENDOUS_IN_BUFFER_SIZE
, OPENDOUS_USB_TIMEOUT
, &result
);
803 #ifdef _DEBUG_USB_COMMS_
804 LOG_DEBUG("USB read end: %d bytes", result
);
806 LOG_DEBUG_IO("opendous_usb_read, result = %d", result
);
808 #ifdef _DEBUG_USB_COMMS_
809 opendous_debug_buffer(usb_in_buffer
, result
);
814 #ifdef _DEBUG_USB_COMMS_
815 #define BYTES_PER_LINE 16
817 void opendous_debug_buffer(uint8_t *buffer
, int length
)
824 for (i
= 0; i
< length
; i
+= BYTES_PER_LINE
) {
825 snprintf(line
, 5, "%04x", i
);
826 for (j
= i
; j
< i
+ BYTES_PER_LINE
&& j
< length
; j
++) {
827 snprintf(s
, 4, " %02x", buffer
[j
]);
830 LOG_DEBUG("%s", line
);
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)