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_common.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 jtag_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_CTX
, "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",
220 .name
= "opendous_hw_jtag",
221 .handler
= &opendous_handle_opendous_hw_jtag_command
,
222 .mode
= COMMAND_EXEC
,
223 .help
= "access opendous HW JTAG command version",
227 .name
= "opendous_type",
228 .handler
= &opendous_handle_opendous_type_command
,
229 .mode
= COMMAND_CONFIG
,
230 .help
= "set opendous type",
231 .usage
= "[usbvlab|usbprog-jtag|opendous]",
233 COMMAND_REGISTRATION_DONE
236 struct jtag_interface opendous_interface
= {
238 .commands
= opendous_command_handlers
,
239 .execute_queue
= opendous_execute_queue
,
240 .init
= opendous_init
,
241 .quit
= opendous_quit
,
244 static int opendous_execute_queue(void)
246 struct jtag_command
*cmd
= jtag_command_queue
;
251 while (cmd
!= NULL
) {
254 DEBUG_JTAG_IO("runtest %i cycles, end in %i", cmd
->cmd
.runtest
->num_cycles
, \
255 cmd
->cmd
.runtest
->end_state
);
257 if (cmd
->cmd
.runtest
->end_state
!= -1)
258 opendous_end_state(cmd
->cmd
.runtest
->end_state
);
259 opendous_runtest(cmd
->cmd
.runtest
->num_cycles
);
263 DEBUG_JTAG_IO("statemove end in %i", cmd
->cmd
.statemove
->end_state
);
265 if (cmd
->cmd
.statemove
->end_state
!= -1)
266 opendous_end_state(cmd
->cmd
.statemove
->end_state
);
267 opendous_state_move();
271 DEBUG_JTAG_IO("pathmove: %i states, end in %i", \
272 cmd
->cmd
.pathmove
->num_states
, \
273 cmd
->cmd
.pathmove
->path
[cmd
->cmd
.pathmove
->num_states
- 1]);
275 opendous_path_move(cmd
->cmd
.pathmove
->num_states
, cmd
->cmd
.pathmove
->path
);
279 DEBUG_JTAG_IO("scan end in %i", cmd
->cmd
.scan
->end_state
);
281 if (cmd
->cmd
.scan
->end_state
!= -1)
282 opendous_end_state(cmd
->cmd
.scan
->end_state
);
284 scan_size
= jtag_build_buffer(cmd
->cmd
.scan
, &buffer
);
285 DEBUG_JTAG_IO("scan input, length = %d", scan_size
);
287 #ifdef _DEBUG_USB_COMMS_
288 opendous_debug_buffer(buffer
, (scan_size
+ 7) / 8);
290 type
= jtag_scan_type(cmd
->cmd
.scan
);
291 opendous_scan(cmd
->cmd
.scan
->ir_scan
, type
, buffer
, scan_size
, cmd
->cmd
.scan
);
295 DEBUG_JTAG_IO("reset trst: %i srst %i", cmd
->cmd
.reset
->trst
, cmd
->cmd
.reset
->srst
);
297 opendous_tap_execute();
299 if (cmd
->cmd
.reset
->trst
== 1)
300 tap_set_state(TAP_RESET
);
301 opendous_reset(cmd
->cmd
.reset
->trst
, cmd
->cmd
.reset
->srst
);
305 DEBUG_JTAG_IO("sleep %" PRIi32
, cmd
->cmd
.sleep
->us
);
306 opendous_tap_execute();
307 jtag_sleep(cmd
->cmd
.sleep
->us
);
311 LOG_ERROR("BUG: unknown JTAG command type encountered");
316 return opendous_tap_execute();
319 static int opendous_init(void)
322 const struct opendous_probe
*cur_opendous_probe
;
324 cur_opendous_probe
= opendous_probes
;
326 if (opendous_type
== NULL
) {
327 opendous_type
= strdup("opendous");
328 LOG_WARNING("No opendous_type specified, using default 'opendous'");
331 while (cur_opendous_probe
->name
) {
332 if (strcmp(cur_opendous_probe
->name
, opendous_type
) == 0) {
333 opendous_probe
= cur_opendous_probe
;
336 cur_opendous_probe
++;
339 if (!opendous_probe
) {
340 LOG_ERROR("No matching cable found for %s", opendous_type
);
341 return ERROR_JTAG_INIT_FAILED
;
345 usb_in_buffer
= malloc(opendous_probe
->BUFFERSIZE
);
346 usb_out_buffer
= malloc(opendous_probe
->BUFFERSIZE
);
348 pending_scan_results_buffer
= malloc(
349 MAX_PENDING_SCAN_RESULTS
* sizeof(*pending_scan_results_buffer
));
351 opendous_jtag_handle
= opendous_usb_open();
353 if (opendous_jtag_handle
== 0) {
354 LOG_ERROR("Cannot find opendous Interface! Please check connection and permissions.");
355 return ERROR_JTAG_INIT_FAILED
;
359 while (check_cnt
< 3) {
360 if (opendous_get_version_info() == ERROR_OK
) {
361 /* attempt to get status */
362 opendous_get_status();
369 LOG_INFO("opendous JTAG Interface ready");
371 opendous_reset(0, 0);
377 static int opendous_quit(void)
379 opendous_usb_close(opendous_jtag_handle
);
381 if (usb_out_buffer
) {
382 free(usb_out_buffer
);
383 usb_out_buffer
= NULL
;
388 usb_in_buffer
= NULL
;
391 if (pending_scan_results_buffer
) {
392 free(pending_scan_results_buffer
);
393 pending_scan_results_buffer
= NULL
;
398 opendous_type
= NULL
;
404 /***************************************************************************/
405 /* Queue command implementations */
407 void opendous_end_state(tap_state_t state
)
409 if (tap_is_state_stable(state
))
410 tap_set_end_state(state
);
412 LOG_ERROR("BUG: %i is not a valid end state", state
);
417 /* Goes to the end state. */
418 void opendous_state_move(void)
422 uint8_t tms_scan
= tap_get_tms_path(tap_get_state(), tap_get_end_state());
423 uint8_t tms_scan_bits
= tap_get_tms_path_len(tap_get_state(), tap_get_end_state());
425 for (i
= 0; i
< tms_scan_bits
; i
++) {
426 tms
= (tms_scan
>> i
) & 1;
427 opendous_tap_append_step(tms
, 0);
430 tap_set_state(tap_get_end_state());
433 void opendous_path_move(int num_states
, tap_state_t
*path
)
437 for (i
= 0; i
< num_states
; i
++) {
438 if (path
[i
] == tap_state_transition(tap_get_state(), false))
439 opendous_tap_append_step(0, 0);
440 else if (path
[i
] == tap_state_transition(tap_get_state(), true))
441 opendous_tap_append_step(1, 0);
443 LOG_ERROR("BUG: %s -> %s isn't a valid TAP transition",
444 tap_state_name(tap_get_state()), tap_state_name(path
[i
]));
448 tap_set_state(path
[i
]);
451 tap_set_end_state(tap_get_state());
454 void opendous_runtest(int num_cycles
)
458 tap_state_t saved_end_state
= tap_get_end_state();
460 /* only do a state_move when we're not already in IDLE */
461 if (tap_get_state() != TAP_IDLE
) {
462 opendous_end_state(TAP_IDLE
);
463 opendous_state_move();
466 /* execute num_cycles */
467 for (i
= 0; i
< num_cycles
; i
++)
468 opendous_tap_append_step(0, 0);
470 /* finish in end_state */
471 opendous_end_state(saved_end_state
);
472 if (tap_get_state() != tap_get_end_state())
473 opendous_state_move();
476 void opendous_scan(int ir_scan
, enum scan_type type
, uint8_t *buffer
, int scan_size
, struct scan_command
*command
)
478 tap_state_t saved_end_state
;
480 opendous_tap_ensure_space(1, scan_size
+ 8);
482 saved_end_state
= tap_get_end_state();
484 /* Move to appropriate scan state */
485 opendous_end_state(ir_scan
? TAP_IRSHIFT
: TAP_DRSHIFT
);
487 if (tap_get_state() != tap_get_end_state())
488 opendous_state_move();
490 opendous_end_state(saved_end_state
);
493 opendous_tap_append_scan(scan_size
, buffer
, command
);
495 /* We are in Exit1, go to Pause */
496 opendous_tap_append_step(0, 0);
498 tap_set_state(ir_scan
? TAP_IRPAUSE
: TAP_DRPAUSE
);
500 if (tap_get_state() != tap_get_end_state())
501 opendous_state_move();
504 void opendous_reset(int trst
, int srst
)
506 LOG_DEBUG("trst: %i, srst: %i", trst
, srst
);
508 /* Signals are active low */
511 opendous_simple_command(JTAG_CMD_SET_SRST
, 1);
513 opendous_simple_command(JTAG_CMD_SET_SRST
, 0);
516 opendous_simple_command(JTAG_CMD_SET_TRST
, 1);
518 opendous_simple_command(JTAG_CMD_SET_TRST
, 0);
523 opendous_simple_command(JTAG_CMD_SET_SRST_TRST
, srst
| trst
);
526 void opendous_simple_command(uint8_t command
, uint8_t _data
)
530 DEBUG_JTAG_IO("0x%02x 0x%02x", command
, _data
);
532 usb_out_buffer
[0] = 2;
533 usb_out_buffer
[1] = 0;
534 usb_out_buffer
[2] = command
;
535 usb_out_buffer
[3] = _data
;
537 result
= opendous_usb_message(opendous_jtag_handle
, 4, 1);
539 LOG_ERROR("opendous command 0x%02x failed (%d)", command
, result
);
542 int opendous_get_status(void)
547 int opendous_get_version_info(void)
552 /***************************************************************************/
553 /* Estick tap functions */
555 static int tap_length
;
556 static uint8_t tms_buffer
[OPENDOUS_TAP_BUFFER_SIZE
];
557 static uint8_t tdo_buffer
[OPENDOUS_TAP_BUFFER_SIZE
];
561 void opendous_tap_init(void)
564 pending_scan_results_length
= 0;
567 void opendous_tap_ensure_space(int scans
, int bits
)
569 int available_scans
= MAX_PENDING_SCAN_RESULTS
- pending_scan_results_length
;
570 int available_bits
= OPENDOUS_TAP_BUFFER_SIZE
/ 2 - tap_length
;
572 if ((scans
> available_scans
) || (bits
> available_bits
))
573 opendous_tap_execute();
576 void opendous_tap_append_step(int tms
, int tdi
)
579 unsigned char _tms
= tms
? 1 : 0;
580 unsigned char _tdi
= tdi
? 1 : 0;
582 opendous_tap_ensure_space(0, 1);
584 int tap_index
= tap_length
/ 4;
585 int bits
= (tap_length
% 4) * 2;
587 if (tap_length
< OPENDOUS_TAP_BUFFER_SIZE
) {
589 tms_buffer
[tap_index
] = 0;
591 tms_buffer
[tap_index
] |= (_tdi
<< bits
)|(_tms
<< (bits
+ 1)) ;
594 LOG_ERROR("opendous_tap_append_step, overflow");
597 void opendous_tap_append_scan(int length
, uint8_t *buffer
, struct scan_command
*command
)
599 DEBUG_JTAG_IO("append scan, length = %d", length
);
601 struct pending_scan_result
*pending_scan_result
= &pending_scan_results_buffer
[pending_scan_results_length
];
604 pending_scan_result
->first
= tap_length
;
605 pending_scan_result
->length
= length
;
606 pending_scan_result
->command
= command
;
607 pending_scan_result
->buffer
= buffer
;
609 for (i
= 0; i
< length
; i
++)
610 opendous_tap_append_step((i
< length
-1 ? 0 : 1), (buffer
[i
/ 8] >> (i
% 8)) & 1);
611 pending_scan_results_length
++;
614 /* Pad and send a tap sequence to the device, and receive the answer.
615 * For the purpose of padding we assume that we are in idle or pause state. */
616 int opendous_tap_execute(void)
622 #ifdef _DEBUG_USB_COMMS_
626 if (tap_length
> 0) {
628 /* memset(tdo_buffer,0,OPENDOUS_TAP_BUFFER_SIZE); */
629 /* LOG_INFO("OPENDOUS tap execute %d",tap_length); */
630 byte_length
= (tap_length
+ 3) / 4;
632 #ifdef _DEBUG_USB_COMMS_
633 byte_length_out
= (tap_length
+ 7) / 8;
634 LOG_DEBUG("opendous is sending %d bytes", byte_length
);
637 for (j
= 0, i
= 0; j
< byte_length
;) {
640 int transmit
= byte_length
- j
;
641 if (transmit
> OPENDOUS_MAX_TAP_TRANSMIT
) {
642 transmit
= OPENDOUS_MAX_TAP_TRANSMIT
;
643 receive
= (OPENDOUS_MAX_TAP_TRANSMIT
) / 2;
644 usb_out_buffer
[2] = JTAG_CMD_TAP_OUTPUT
;
646 usb_out_buffer
[2] = JTAG_CMD_TAP_OUTPUT
| ((tap_length
% 4) << 4);
647 receive
= (transmit
+ 1) / 2;
649 usb_out_buffer
[0] = (transmit
+ 1) & 0xff;
650 usb_out_buffer
[1] = ((transmit
+ 1) >> 8) & 0xff;
652 memmove(usb_out_buffer
+ 3, tms_buffer
+ j
, transmit
);
653 result
= opendous_usb_message(opendous_jtag_handle
, 3 + transmit
, receive
);
654 if (result
!= receive
) {
655 LOG_ERROR("opendous_tap_execute, wrong result %d, expected %d", result
, receive
);
656 return ERROR_JTAG_QUEUE_FAILED
;
659 memmove(tdo_buffer
+ i
, usb_in_buffer
, receive
);
664 #ifdef _DEBUG_USB_COMMS_
665 LOG_DEBUG("opendous tap result %d", byte_length_out
);
666 opendous_debug_buffer(tdo_buffer
, byte_length_out
);
669 /* LOG_INFO("eStick tap execute %d",tap_length); */
670 for (i
= 0; i
< pending_scan_results_length
; i
++) {
672 struct pending_scan_result
*pending_scan_result
= &pending_scan_results_buffer
[i
];
673 uint8_t *buffer
= pending_scan_result
->buffer
;
674 int length
= pending_scan_result
->length
;
675 int first
= pending_scan_result
->first
;
676 struct scan_command
*command
= pending_scan_result
->command
;
679 buf_set_buf(tdo_buffer
, first
, buffer
, 0, length
);
681 DEBUG_JTAG_IO("pending scan result, length = %d", length
);
683 #ifdef _DEBUG_USB_COMMS_
684 opendous_debug_buffer(buffer
, byte_length_out
);
687 if (jtag_read_buffer(buffer
, command
) != ERROR_OK
) {
689 return ERROR_JTAG_QUEUE_FAILED
;
692 if (pending_scan_result
->buffer
!= NULL
)
693 free(pending_scan_result
->buffer
);
702 /*****************************************************************************/
703 /* Estick USB low-level functions */
705 struct opendous_jtag
*opendous_usb_open(void)
707 struct opendous_jtag
*result
;
709 struct jtag_libusb_device_handle
*devh
;
710 if (jtag_libusb_open(opendous_probe
->VID
, opendous_probe
->PID
, NULL
, &devh
) != ERROR_OK
)
713 jtag_libusb_set_configuration(devh
, 0);
714 jtag_libusb_claim_interface(devh
, 0);
716 result
= malloc(sizeof(*result
));
717 result
->usb_handle
= devh
;
721 void opendous_usb_close(struct opendous_jtag
*opendous_jtag
)
723 jtag_libusb_close(opendous_jtag
->usb_handle
);
727 /* Send a message and receive the reply. */
728 int opendous_usb_message(struct opendous_jtag
*opendous_jtag
, int out_length
, int in_length
)
732 result
= opendous_usb_write(opendous_jtag
, out_length
);
733 if (result
== out_length
) {
734 result
= opendous_usb_read(opendous_jtag
);
735 if (result
== in_length
)
738 LOG_ERROR("usb_bulk_read failed (requested=%d, result=%d)", in_length
, result
);
742 LOG_ERROR("usb_bulk_write failed (requested=%d, result=%d)", out_length
, result
);
747 /* Write data from out_buffer to USB. */
748 int opendous_usb_write(struct opendous_jtag
*opendous_jtag
, int out_length
)
752 if (out_length
> OPENDOUS_OUT_BUFFER_SIZE
) {
753 LOG_ERROR("opendous_jtag_write illegal out_length=%d (max=%d)", out_length
, OPENDOUS_OUT_BUFFER_SIZE
);
757 #ifdef _DEBUG_USB_COMMS_
758 LOG_DEBUG("USB write begin");
760 if (opendous_probe
->CONTROL_TRANSFER
) {
761 result
= jtag_libusb_control_transfer(opendous_jtag
->usb_handle
,
762 LIBUSB_REQUEST_TYPE_VENDOR
| LIBUSB_RECIPIENT_DEVICE
| LIBUSB_ENDPOINT_OUT
,
763 FUNC_WRITE_DATA
, 0, 0, (char *) usb_out_buffer
, out_length
, OPENDOUS_USB_TIMEOUT
);
765 result
= jtag_libusb_bulk_write(opendous_jtag
->usb_handle
, OPENDOUS_WRITE_ENDPOINT
, \
766 (char *)usb_out_buffer
, out_length
, OPENDOUS_USB_TIMEOUT
);
768 #ifdef _DEBUG_USB_COMMS_
769 LOG_DEBUG("USB write end: %d bytes", result
);
772 DEBUG_JTAG_IO("opendous_usb_write, out_length = %d, result = %d", out_length
, result
);
774 #ifdef _DEBUG_USB_COMMS_
775 opendous_debug_buffer(usb_out_buffer
, out_length
);
780 /* Read data from USB into in_buffer. */
781 int opendous_usb_read(struct opendous_jtag
*opendous_jtag
)
783 #ifdef _DEBUG_USB_COMMS_
784 LOG_DEBUG("USB read begin");
787 if (opendous_probe
->CONTROL_TRANSFER
) {
788 result
= jtag_libusb_control_transfer(opendous_jtag
->usb_handle
,
789 LIBUSB_REQUEST_TYPE_VENDOR
| LIBUSB_RECIPIENT_DEVICE
| LIBUSB_ENDPOINT_IN
,
790 FUNC_READ_DATA
, 0, 0, (char *) usb_in_buffer
, OPENDOUS_IN_BUFFER_SIZE
, OPENDOUS_USB_TIMEOUT
);
792 result
= jtag_libusb_bulk_read(opendous_jtag
->usb_handle
, OPENDOUS_READ_ENDPOINT
,
793 (char *)usb_in_buffer
, OPENDOUS_IN_BUFFER_SIZE
, OPENDOUS_USB_TIMEOUT
);
795 #ifdef _DEBUG_USB_COMMS_
796 LOG_DEBUG("USB read end: %d bytes", result
);
798 DEBUG_JTAG_IO("opendous_usb_read, result = %d", result
);
800 #ifdef _DEBUG_USB_COMMS_
801 opendous_debug_buffer(usb_in_buffer
, result
);
806 #ifdef _DEBUG_USB_COMMS_
807 #define BYTES_PER_LINE 16
809 void opendous_debug_buffer(uint8_t *buffer
, int length
)
816 for (i
= 0; i
< length
; i
+= BYTES_PER_LINE
) {
817 snprintf(line
, 5, "%04x", i
);
818 for (j
= i
; j
< i
+ BYTES_PER_LINE
&& j
< length
; j
++) {
819 snprintf(s
, 4, " %02x", buffer
[j
]);
822 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)