1 /***************************************************************************
2 * Copyright (C) 2009-2010 by Simon Qian <SimonQian@SimonQian.com> *
4 * This program is free software; you can redistribute it and/or modify *
5 * it under the terms of the GNU General Public License as published by *
6 * the Free Software Foundation; either version 2 of the License, or *
7 * (at your option) any later version. *
9 * This program is distributed in the hope that it will be useful, *
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
12 * GNU General Public License for more details. *
14 * You should have received a copy of the GNU General Public License *
15 * along with this program; if not, write to the *
16 * Free Software Foundation, Inc., *
17 * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
18 ***************************************************************************/
20 /* Versaloon is a programming tool for multiple MCUs.
21 * It's distributed under GPLv3.
22 * You can find it at http://www.SimonQian.com/en/Versaloon.
29 #include <jtag/interface.h>
30 #include <jtag/commands.h>
31 #include "usb_common.h"
33 //#define _VSLLINK_IN_DEBUG_MODE_
35 static uint16_t vsllink_usb_vid
;
36 static uint16_t vsllink_usb_pid
;
37 static uint8_t vsllink_usb_bulkout
;
38 static uint8_t vsllink_usb_bulkin
;
39 static uint8_t vsllink_usb_interface
;
40 static int VSLLINK_USB_TIMEOUT
= 1000;
42 static int vsllink_tms_offset
;
44 /* Global USB buffers */
45 static uint8_t *vsllink_usb_in_buffer
;
46 static uint8_t *vsllink_usb_out_buffer
;
47 static int vsllink_buffer_size
= 128;
49 /* Constants for Versaloon command */
50 #define VERSALOON_GET_INFO 0x00
51 #define VERSALOON_GET_TVCC 0x01
53 /* Constants for VSLLink command */
54 #define VSLLINK_CMD_CONN 0x80
55 #define VSLLINK_CMD_DISCONN 0x81
56 #define VSLLINK_CMD_SET_SPEED 0x82
57 #define VSLLINK_CMD_SET_PORT 0x90
58 #define VSLLINK_CMD_GET_PORT 0x91
59 #define VSLLINK_CMD_SET_PORTDIR 0x92
60 #define VSLLINK_CMD_HW_JTAGSEQCMD 0xA0
61 #define VSLLINK_CMD_HW_JTAGHLCMD 0xA1
62 #define VSLLINK_CMD_HW_SWDCMD 0xA2
63 #define VSLLINK_CMD_HW_JTAGRAWCMD 0xA3
65 #define VSLLINK_CMDJTAGSEQ_TMSBYTE 0x00
66 #define VSLLINK_CMDJTAGSEQ_TMSCLOCK 0x40
67 #define VSLLINK_CMDJTAGSEQ_SCAN 0x80
69 #define VSLLINK_CMDJTAGSEQ_CMDMSK 0xC0
70 #define VSLLINK_CMDJTAGSEQ_LENMSK 0x3F
72 #define JTAG_PINMSK_SRST (1 << 0)
73 #define JTAG_PINMSK_TRST (1 << 1)
74 #define JTAG_PINMSK_USR1 (1 << 2)
75 #define JTAG_PINMSK_USR2 (1 << 3)
76 #define JTAG_PINMSK_TCK (1 << 4)
77 #define JTAG_PINMSK_TMS (1 << 5)
78 #define JTAG_PINMSK_TDI (1 << 6)
79 #define JTAG_PINMSK_TDO (1 << 7)
81 struct pending_scan_result
{
84 int length
; /* Number of bits to read */
85 struct scan_command
*command
; /* Corresponding scan command */
87 bool last
; /* indicate the last scan pending */
90 #define MAX_PENDING_SCAN_RESULTS 256
92 static int pending_scan_results_length
;
93 static struct pending_scan_result
94 pending_scan_results_buffer
[MAX_PENDING_SCAN_RESULTS
];
96 /* Queue command functions */
97 static void vsllink_end_state(tap_state_t state
);
98 static void vsllink_state_move(void);
99 static void vsllink_path_move(int num_states
, tap_state_t
*path
);
100 static void vsllink_runtest(int num_cycles
);
101 static void vsllink_stableclocks(int num_cycles
, int tms
);
102 static void vsllink_scan(bool ir_scan
, enum scan_type type
,
103 uint8_t *buffer
, int scan_size
, struct scan_command
*command
);
104 static void vsllink_reset(int trst
, int srst
);
105 static void vsllink_simple_command(uint8_t command
);
107 /* VSLLink tap buffer functions */
108 static void vsllink_tap_append_step(int tms
, int tdi
);
109 static void vsllink_tap_init(void);
110 static int vsllink_tap_execute(void);
111 static void vsllink_tap_ensure_pending(int scans
);
112 static void vsllink_tap_append_scan(int length
, uint8_t *buffer
,
113 struct scan_command
*command
);
115 /* VSLLink lowlevel functions */
117 struct usb_dev_handle
*usb_handle
;
120 static struct vsllink
*vsllink_usb_open(void);
121 static void vsllink_usb_close(struct vsllink
*vsllink
);
122 static int vsllink_usb_message(struct vsllink
*vsllink
, int out_length
,
124 static int vsllink_usb_write(struct vsllink
*vsllink
, int out_length
);
125 static int vsllink_usb_read(struct vsllink
*vsllink
);
127 #if defined _DEBUG_USB_COMMS_ || defined _DEBUG_JTAG_IO_
128 static void vsllink_debug_buffer(uint8_t *buffer
, int length
);
131 static int tap_length
;
132 static int tap_buffer_size
;
133 static uint8_t *tms_buffer
;
134 static uint8_t *tdi_buffer
;
135 static uint8_t *tdo_buffer
;
137 static struct vsllink
*vsllink_handle
;
139 static void reset_command_pointer(void)
144 static int vsllink_execute_queue(void)
146 struct jtag_command
*cmd
= jtag_command_queue
;
151 DEBUG_JTAG_IO("-------------------------------------"
153 "-------------------------------------");
155 reset_command_pointer();
156 while (cmd
!= NULL
) {
159 DEBUG_JTAG_IO("runtest %i cycles, end in %s",
160 cmd
->cmd
.runtest
->num_cycles
,
161 tap_state_name(cmd
->cmd
.runtest
164 vsllink_end_state(cmd
->cmd
.runtest
->end_state
);
165 vsllink_runtest(cmd
->cmd
.runtest
->num_cycles
);
169 DEBUG_JTAG_IO("statemove end in %s",
170 tap_state_name(cmd
->cmd
.statemove
173 vsllink_end_state(cmd
->cmd
.statemove
175 vsllink_state_move();
179 DEBUG_JTAG_IO("pathmove: %i states, end in %s",
180 cmd
->cmd
.pathmove
->num_states
,
181 tap_state_name(cmd
->cmd
.pathmove
182 ->path
[cmd
->cmd
.pathmove
186 cmd
->cmd
.pathmove
->num_states
,
187 cmd
->cmd
.pathmove
->path
);
191 vsllink_end_state(cmd
->cmd
.scan
->end_state
);
193 scan_size
= jtag_build_buffer(
194 cmd
->cmd
.scan
, &buffer
);
196 if (cmd
->cmd
.scan
->ir_scan
)
198 "JTAG Scan write IR(%d bits), "
201 tap_state_name(cmd
->cmd
.scan
206 "JTAG Scan write DR(%d bits), "
209 tap_state_name(cmd
->cmd
.scan
212 #ifdef _DEBUG_JTAG_IO_
213 vsllink_debug_buffer(buffer
,
214 DIV_ROUND_UP(scan_size
, 8));
217 type
= jtag_scan_type(cmd
->cmd
.scan
);
219 vsllink_scan(cmd
->cmd
.scan
->ir_scan
,
220 type
, buffer
, scan_size
,
225 DEBUG_JTAG_IO("reset trst: %i srst %i",
226 cmd
->cmd
.reset
->trst
,
227 cmd
->cmd
.reset
->srst
);
229 vsllink_tap_execute();
231 if (cmd
->cmd
.reset
->trst
== 1)
232 tap_set_state(TAP_RESET
);
234 vsllink_reset(cmd
->cmd
.reset
->trst
,
235 cmd
->cmd
.reset
->srst
);
239 DEBUG_JTAG_IO("sleep %i", cmd
->cmd
.sleep
->us
);
240 vsllink_tap_execute();
241 jtag_sleep(cmd
->cmd
.sleep
->us
);
244 case JTAG_STABLECLOCKS
:
245 DEBUG_JTAG_IO("add %d clocks",
246 cmd
->cmd
.stableclocks
->num_cycles
);
247 switch (tap_get_state()) {
249 /* tms must be '1' to stay
259 /* else, tms should be '0' */
262 /* above stable states are OK */
264 LOG_ERROR("jtag_add_clocks() "
265 "in non-stable state \"%s\"",
266 tap_state_name(tap_get_state())
270 vsllink_stableclocks(cmd
->cmd
.stableclocks
271 ->num_cycles
, scan_size
);
275 LOG_ERROR("BUG: unknown JTAG command type "
276 "encountered: %d", cmd
->type
);
282 return vsllink_tap_execute();
285 static int vsllink_speed(int speed
)
289 vsllink_usb_out_buffer
[0] = VSLLINK_CMD_SET_SPEED
;
290 vsllink_usb_out_buffer
[1] = (speed
>> 0) & 0xff;
291 vsllink_usb_out_buffer
[2] = (speed
>> 8) & 0xFF;
293 result
= vsllink_usb_write(vsllink_handle
, 3);
298 LOG_ERROR("VSLLink setting speed failed (%d)", result
);
299 return ERROR_JTAG_DEVICE_ERROR
;
305 static int vsllink_khz(int khz
, int *jtag_speed
)
312 static int vsllink_speed_div(int jtag_speed
, int *khz
)
319 static int vsllink_init(void)
321 int check_cnt
, to_tmp
;
323 char version_str
[100];
325 vsllink_usb_in_buffer
= malloc(vsllink_buffer_size
);
326 vsllink_usb_out_buffer
= malloc(vsllink_buffer_size
);
327 if ((vsllink_usb_in_buffer
== NULL
)
328 || (vsllink_usb_out_buffer
== NULL
)) {
329 LOG_ERROR("Not enough memory");
333 vsllink_handle
= vsllink_usb_open();
334 if (vsllink_handle
== 0) {
335 LOG_ERROR("Can't find USB JTAG Interface!"\
336 "Please check connection and permissions.");
337 return ERROR_JTAG_INIT_FAILED
;
339 LOG_DEBUG("vsllink found on %04X:%04X",
340 vsllink_usb_vid
, vsllink_usb_pid
);
342 to_tmp
= VSLLINK_USB_TIMEOUT
;
343 VSLLINK_USB_TIMEOUT
= 100;
345 while (check_cnt
< 5) {
346 vsllink_simple_command(VERSALOON_GET_INFO
);
347 result
= vsllink_usb_read(vsllink_handle
);
350 vsllink_usb_in_buffer
[result
] = 0;
351 vsllink_buffer_size
= vsllink_usb_in_buffer
[0]
352 + (vsllink_usb_in_buffer
[1] << 8);
353 strncpy(version_str
, (char *)vsllink_usb_in_buffer
+ 2,
354 sizeof(version_str
));
355 LOG_INFO("%s", version_str
);
357 /* free the pre-allocated memory */
358 free(vsllink_usb_in_buffer
);
359 free(vsllink_usb_out_buffer
);
360 vsllink_usb_in_buffer
= NULL
;
361 vsllink_usb_out_buffer
= NULL
;
363 /* alloc new memory */
364 vsllink_usb_in_buffer
= malloc(vsllink_buffer_size
);
365 vsllink_usb_out_buffer
= malloc(vsllink_buffer_size
);
366 if ((vsllink_usb_in_buffer
== NULL
) ||
367 (vsllink_usb_out_buffer
== NULL
)) {
368 LOG_ERROR("Not enough memory");
371 LOG_INFO("buffer size for USB is %d bytes",
372 vsllink_buffer_size
);
374 /* alloc tms/tdi/tdo buffer */
375 tap_buffer_size
= (vsllink_buffer_size
- 3) / 2;
376 tms_buffer
= (uint8_t *)malloc(tap_buffer_size
);
377 tdi_buffer
= (uint8_t *)malloc(tap_buffer_size
);
378 tdo_buffer
= (uint8_t *)malloc(tap_buffer_size
);
379 if ((tms_buffer
== NULL
) || (tdi_buffer
== NULL
) ||
380 (tdo_buffer
== NULL
)) {
381 LOG_ERROR("Not enough memory");
386 vsllink_simple_command(VSLLINK_CMD_DISCONN
);
389 if (check_cnt
== 3) {
390 /* Fail to access Versaloon */
391 LOG_ERROR("VSLLink initial failed");
394 VSLLINK_USB_TIMEOUT
= to_tmp
;
396 /* Some older firmware versions sometimes fail if the
397 * voltage isn't read first.
399 vsllink_simple_command(VERSALOON_GET_TVCC
);
400 result
= vsllink_usb_read(vsllink_handle
);
402 LOG_WARNING("Fail to get target voltage");
404 LOG_INFO("Target runs at %d mV", vsllink_usb_in_buffer
[0] +
405 (vsllink_usb_in_buffer
[1] << 8));
407 /* connect to vsllink */
408 vsllink_usb_out_buffer
[0] = VSLLINK_CMD_CONN
;
409 vsllink_usb_out_buffer
[1] = 1;
410 vsllink_usb_message(vsllink_handle
, 2, 0);
411 if (vsllink_usb_read(vsllink_handle
) > 2) {
412 strncpy(version_str
, (char *)vsllink_usb_in_buffer
+ 2,
413 sizeof(version_str
));
414 LOG_INFO("%s", version_str
);
417 /* Set SRST and TRST to output, Set USR1 and USR2 to input */
418 vsllink_usb_out_buffer
[0] = VSLLINK_CMD_SET_PORTDIR
;
419 vsllink_usb_out_buffer
[1] = JTAG_PINMSK_SRST
| JTAG_PINMSK_TRST
420 | JTAG_PINMSK_USR1
| JTAG_PINMSK_USR2
;
421 vsllink_usb_out_buffer
[2] = JTAG_PINMSK_SRST
| JTAG_PINMSK_TRST
;
422 if (vsllink_usb_write(vsllink_handle
, 3) != 3) {
423 LOG_ERROR("VSLLink USB send data error");
429 LOG_INFO("VSLLink Interface ready");
436 static int vsllink_quit(void)
438 if ((vsllink_usb_in_buffer
!= NULL
)
439 && (vsllink_usb_out_buffer
!= NULL
)) {
440 // Set all pins to input
441 vsllink_usb_out_buffer
[0] = VSLLINK_CMD_SET_PORTDIR
;
442 vsllink_usb_out_buffer
[1] = JTAG_PINMSK_SRST
| JTAG_PINMSK_TRST
443 | JTAG_PINMSK_USR1
| JTAG_PINMSK_USR2
;
444 vsllink_usb_out_buffer
[2] = 0;
445 if (vsllink_usb_write(vsllink_handle
, 3) != 3) {
446 LOG_ERROR("VSLLink USB send data error");
451 vsllink_simple_command(VSLLINK_CMD_DISCONN
);
452 vsllink_usb_close(vsllink_handle
);
453 vsllink_handle
= NULL
;
456 if (vsllink_usb_in_buffer
!= NULL
) {
457 free(vsllink_usb_in_buffer
);
458 vsllink_usb_in_buffer
= NULL
;
460 if (vsllink_usb_out_buffer
!= NULL
) {
461 free(vsllink_usb_out_buffer
);
462 vsllink_usb_out_buffer
= NULL
;
468 /***************************************************************************/
469 /* Queue command implementations */
471 static void vsllink_end_state(tap_state_t state
)
473 if (tap_is_state_stable(state
))
474 tap_set_end_state(state
);
476 LOG_ERROR("BUG: %i is not a valid end state", state
);
481 /* Goes to the end state. */
482 static void vsllink_state_move(void)
485 uint8_t tms_scan
= tap_get_tms_path(tap_get_state(),
486 tap_get_end_state());
487 uint8_t tms_scan_bits
= tap_get_tms_path_len(tap_get_state(),
488 tap_get_end_state());
490 for (i
= 0; i
< tms_scan_bits
; i
++)
491 vsllink_tap_append_step((tms_scan
>> i
) & 1, 0);
493 tap_set_state(tap_get_end_state());
496 static void vsllink_path_move(int num_states
, tap_state_t
*path
)
498 for (int i
= 0; i
< num_states
; i
++) {
499 if (path
[i
] == tap_state_transition(tap_get_state(), false))
500 vsllink_tap_append_step(0, 0);
501 else if (path
[i
] == tap_state_transition(tap_get_state(), true))
502 vsllink_tap_append_step(1, 0);
504 LOG_ERROR("BUG: %s -> %s isn't a valid TAP transition",
505 tap_state_name(tap_get_state()),
506 tap_state_name(path
[i
]));
510 tap_set_state(path
[i
]);
513 tap_set_end_state(tap_get_state());
516 static void vsllink_stableclocks(int num_cycles
, int tms
)
518 while (num_cycles
> 0) {
519 vsllink_tap_append_step(tms
, 0);
524 static void vsllink_runtest(int num_cycles
)
526 tap_state_t saved_end_state
= tap_get_end_state();
528 if (tap_get_state() != TAP_IDLE
) {
529 /* enter IDLE state */
530 vsllink_end_state(TAP_IDLE
);
531 vsllink_state_move();
534 vsllink_stableclocks(num_cycles
, 0);
538 vsllink_end_state(saved_end_state
);
539 if (tap_get_end_state() != tap_get_end_state())
540 vsllink_state_move();
543 static void vsllink_scan(bool ir_scan
, enum scan_type type
, uint8_t *buffer
,
544 int scan_size
, struct scan_command
*command
)
546 tap_state_t saved_end_state
;
548 saved_end_state
= tap_get_end_state();
550 /* Move to appropriate scan state */
551 vsllink_end_state(ir_scan
? TAP_IRSHIFT
: TAP_DRSHIFT
);
553 if (tap_get_state() != tap_get_end_state())
554 vsllink_state_move();
555 vsllink_end_state(saved_end_state
);
558 vsllink_tap_append_scan(scan_size
, buffer
, command
);
560 /* Goto Pause and record position to insert tms:0 */
561 vsllink_tap_append_step(0, 0);
562 vsllink_tms_offset
= tap_length
;
564 tap_set_state(ir_scan
? TAP_IRPAUSE
: TAP_DRPAUSE
);
566 if (tap_get_state() != tap_get_end_state())
567 vsllink_state_move();
570 static void vsllink_reset(int trst
, int srst
)
574 LOG_DEBUG("trst: %i, srst: %i", trst
, srst
);
576 /* Signals are active low */
577 vsllink_usb_out_buffer
[0] = VSLLINK_CMD_SET_PORT
;
578 vsllink_usb_out_buffer
[1] = JTAG_PINMSK_SRST
| JTAG_PINMSK_TRST
;
579 vsllink_usb_out_buffer
[2] = 0;
581 vsllink_usb_out_buffer
[2] |= JTAG_PINMSK_SRST
;
583 vsllink_usb_out_buffer
[2] |= JTAG_PINMSK_TRST
;
585 result
= vsllink_usb_write(vsllink_handle
, 3);
587 LOG_ERROR("VSLLink command VSLLINK_CMD_SET_PORT failed (%d)",
591 static void vsllink_simple_command(uint8_t command
)
595 DEBUG_JTAG_IO("0x%02x", command
);
597 vsllink_usb_out_buffer
[0] = command
;
598 result
= vsllink_usb_write(vsllink_handle
, 1);
601 LOG_ERROR("VSLLink command 0x%02x failed (%d)",
605 COMMAND_HANDLER(vsllink_handle_mode_command
)
608 LOG_ERROR("parameter error, "
609 "should be one parameter for mode");
616 COMMAND_HANDLER(vsllink_handle_usb_vid_command
)
619 LOG_ERROR("parameter error, "
620 "should be one parameter for VID");
624 COMMAND_PARSE_NUMBER(u16
, CMD_ARGV
[0], vsllink_usb_vid
);
628 COMMAND_HANDLER(vsllink_handle_usb_pid_command
)
631 LOG_ERROR("parameter error, "
632 "should be one parameter for PID");
635 COMMAND_PARSE_NUMBER(u16
, CMD_ARGV
[0], vsllink_usb_pid
);
639 COMMAND_HANDLER(vsllink_handle_usb_bulkin_command
)
642 LOG_ERROR("parameter error, "
643 "should be one parameter for BULKIN endpoint");
647 COMMAND_PARSE_NUMBER(u8
, CMD_ARGV
[0], vsllink_usb_bulkin
);
649 vsllink_usb_bulkin
|= 0x80;
654 COMMAND_HANDLER(vsllink_handle_usb_bulkout_command
)
657 LOG_ERROR("parameter error, "
658 "should be one parameter for BULKOUT endpoint");
662 COMMAND_PARSE_NUMBER(u8
, CMD_ARGV
[0], vsllink_usb_bulkout
);
664 vsllink_usb_bulkout
&= ~0x80;
669 COMMAND_HANDLER(vsllink_handle_usb_interface_command
)
672 LOG_ERROR("parameter error, "
673 "should be one parameter for interface number");
677 COMMAND_PARSE_NUMBER(u8
, CMD_ARGV
[0], vsllink_usb_interface
);
681 /***************************************************************************/
682 /* VSLLink tap functions */
684 static void vsllink_tap_init(void)
687 pending_scan_results_length
= 0;
688 vsllink_tms_offset
= 0;
691 static void vsllink_tap_ensure_pending(int scans
)
693 int available_scans
=
694 MAX_PENDING_SCAN_RESULTS
- pending_scan_results_length
;
696 if (scans
> available_scans
)
697 vsllink_tap_execute();
700 static void vsllink_tap_append_step(int tms
, int tdi
)
702 int index
= tap_length
/ 8;
704 int bit_index
= tap_length
% 8;
705 uint8_t bit
= 1 << bit_index
;
708 tms_buffer
[index
] |= bit
;
710 tms_buffer
[index
] &= ~bit
;
713 tdi_buffer
[index
] |= bit
;
715 tdi_buffer
[index
] &= ~bit
;
719 if (tap_buffer_size
* 8 <= tap_length
)
720 vsllink_tap_execute();
723 static void vsllink_tap_append_scan(int length
, uint8_t *buffer
,
724 struct scan_command
*command
)
726 struct pending_scan_result
*pending_scan_result
;
727 int len_tmp
, len_all
, i
;
730 while (len_all
< length
) {
731 vsllink_tap_ensure_pending(1);
732 pending_scan_result
=
733 &pending_scan_results_buffer
[
734 pending_scan_results_length
];
736 if ((length
- len_all
) > (tap_buffer_size
* 8 - tap_length
)) {
737 /* Use all memory available
738 vsllink_tap_append_step will commit automatically */
739 len_tmp
= tap_buffer_size
* 8 - tap_length
;
740 pending_scan_result
->last
= false;
742 len_tmp
= length
- len_all
;
743 pending_scan_result
->last
= true;
745 pending_scan_result
->src_offset
= tap_length
;
746 pending_scan_result
->dest_offset
= len_all
;
747 pending_scan_result
->length
= len_tmp
;
748 pending_scan_result
->command
= command
;
749 pending_scan_result
->buffer
= buffer
;
750 pending_scan_results_length
++;
752 for (i
= 0; i
< len_tmp
; i
++) {
753 vsllink_tap_append_step(((len_all
+ i
) < length
-1
755 (buffer
[(len_all
+ i
)/8]
756 >> ((len_all
+ i
)%8)) & 1);
763 static int vsllink_tap_execute(void)
772 /* Pad data so that tap_length is divisible by 8 */
773 if ((tap_length
% 8) != 0) {
774 if (vsllink_tms_offset
> 0) {
775 /* append tms:0 at vsllink_tms_offset,
778 int start_pos
= DIV_ROUND_UP(tap_length
, 8) - 1;
779 int end_pos
= DIV_ROUND_UP(vsllink_tms_offset
, 8) - 1;
780 int shift_cnt
= (start_pos
+ 1) * 8 - tap_length
;
781 uint8_t last_mask
= ~(
782 (1 << (vsllink_tms_offset
% 8)) - 1);
785 if (start_pos
== end_pos
) {
786 tms_buffer
[start_pos
] =
787 (tms_buffer
[start_pos
]
789 | ((tms_buffer
[start_pos
]
792 tdi_buffer
[start_pos
] =
793 (tdi_buffer
[start_pos
]
796 ((tdi_buffer
[start_pos
]
800 } else if (start_pos
== (end_pos
+ 1)) {
801 tms_buffer
[start_pos
] =
802 (tms_buffer
[start_pos
]
804 ((tms_buffer
[start_pos
- 1]
807 tdi_buffer
[start_pos
] =
808 (tdi_buffer
[start_pos
]
810 ((tdi_buffer
[start_pos
- 1]
814 tms_buffer
[start_pos
] =
815 (tms_buffer
[start_pos
]
817 (tms_buffer
[start_pos
- 1]
819 tdi_buffer
[start_pos
] =
820 (tdi_buffer
[start_pos
]
822 (tdi_buffer
[start_pos
- 1]
827 tap_length
= DIV_ROUND_UP(tap_length
, 8) * 8;
829 /* append data at last */
830 while ((tap_length
% 8) != 0) {
831 vsllink_tap_append_step(
832 (tap_get_state() == TAP_RESET
)
837 byte_length
= tap_length
/ 8;
839 vsllink_usb_out_buffer
[0] = VSLLINK_CMD_HW_JTAGRAWCMD
;
840 vsllink_usb_out_buffer
[1] = ((byte_length
* 2 + 3) >> 0) & 0xff;
841 vsllink_usb_out_buffer
[2] = ((byte_length
* 2 + 3) >> 8) & 0xff;
843 memcpy(&vsllink_usb_out_buffer
[3], tdi_buffer
, byte_length
);
844 memcpy(&vsllink_usb_out_buffer
[3 + byte_length
], tms_buffer
,
847 result
= vsllink_usb_message(vsllink_handle
, 3 + 2 * byte_length
,
850 if (result
== byte_length
) {
851 for (i
= 0; i
< pending_scan_results_length
; i
++) {
852 struct pending_scan_result
*pending_scan_result
=
853 &pending_scan_results_buffer
[i
];
854 uint8_t *buffer
= pending_scan_result
->buffer
;
855 int length
= pending_scan_result
->length
;
856 int src_first
= pending_scan_result
->src_offset
;
857 int dest_first
= pending_scan_result
->dest_offset
;
858 bool last
= pending_scan_result
->last
;
860 struct scan_command
*command
;
862 command
= pending_scan_result
->command
;
863 buf_set_buf(vsllink_usb_in_buffer
, src_first
, buffer
,
866 DEBUG_JTAG_IO("JTAG scan read(%d bits, from %d bits):",
868 #ifdef _DEBUG_JTAG_IO_
869 vsllink_debug_buffer(buffer
+ dest_first
/ 8,
870 DIV_ROUND_UP(length
, 7));
874 if (jtag_read_buffer(buffer
, command
)
877 return ERROR_JTAG_QUEUE_FAILED
;
880 if (pending_scan_result
->buffer
!= NULL
)
881 free(pending_scan_result
->buffer
);
885 LOG_ERROR("vsllink_tap_execute, wrong result %d, expected %d",
886 result
, byte_length
);
887 return ERROR_JTAG_QUEUE_FAILED
;
895 /*****************************************************************************/
896 /* VSLLink USB low-level functions */
898 static struct vsllink
*vsllink_usb_open(void)
902 const uint16_t vids
[] = { vsllink_usb_vid
, 0 };
903 const uint16_t pids
[] = { vsllink_usb_pid
, 0 };
904 struct usb_dev_handle
*dev
;
905 if (jtag_usb_open(vids
, pids
, &dev
) != ERROR_OK
)
908 /* usb_set_configuration required under win32 */
909 struct usb_device
*udev
= usb_device(dev
);
910 int ret
= usb_set_configuration(dev
,
911 udev
->config
[0].bConfigurationValue
);
913 LOG_ERROR("fail to set configuration to %d (error %d)."
914 "Not enough permissions for the device?",
915 udev
->config
[0].bConfigurationValue
, ret
);
918 ret
= usb_claim_interface(dev
, vsllink_usb_interface
);
920 LOG_ERROR("fail to claim interface %d, %d returned",
921 vsllink_usb_interface
, ret
);
926 * This makes problems under Mac OS X. And is not needed
927 * under Windows. Hopefully this will not break a linux build
929 usb_set_altinterface(dev
, 0);
932 struct vsllink
*result
= malloc(sizeof(struct vsllink
));
933 result
->usb_handle
= dev
;
937 static void vsllink_usb_close(struct vsllink
*vsllink
)
941 ret
= usb_release_interface(vsllink
->usb_handle
,
942 vsllink_usb_interface
);
944 LOG_ERROR("fail to release interface %d, %d returned",
945 vsllink_usb_interface
, ret
);
949 ret
= usb_close(vsllink
->usb_handle
);
951 LOG_ERROR("fail to close usb, %d returned", ret
);
958 /* Send a message and receive the reply. */
959 static int vsllink_usb_message(struct vsllink
*vsllink
, int out_length
,
964 result
= vsllink_usb_write(vsllink
, out_length
);
965 if (result
== out_length
) {
967 result
= vsllink_usb_read(vsllink
);
968 if (result
== in_length
)
971 LOG_ERROR("usb_bulk_read failed "
972 "(requested=%d, result=%d)",
979 LOG_ERROR("usb_bulk_write failed (requested=%d, result=%d)",
985 /* Write data from out_buffer to USB. */
986 static int vsllink_usb_write(struct vsllink
*vsllink
, int out_length
)
990 if (out_length
> vsllink_buffer_size
) {
991 LOG_ERROR("vsllink_write illegal out_length=%d (max=%d)",
992 out_length
, vsllink_buffer_size
);
996 result
= usb_bulk_write(vsllink
->usb_handle
, vsllink_usb_bulkout
,
997 (char *)vsllink_usb_out_buffer
, out_length
,
998 VSLLINK_USB_TIMEOUT
);
1000 DEBUG_JTAG_IO("vsllink_usb_write, out_length = %d, result = %d",
1001 out_length
, result
);
1003 #ifdef _DEBUG_USB_COMMS_
1004 LOG_DEBUG("USB out:");
1005 vsllink_debug_buffer(vsllink_usb_out_buffer
, out_length
);
1008 #ifdef _VSLLINK_IN_DEBUG_MODE_
1015 /* Read data from USB into in_buffer. */
1016 static int vsllink_usb_read(struct vsllink
*vsllink
)
1018 int result
= usb_bulk_read(vsllink
->usb_handle
, vsllink_usb_bulkin
,
1019 (char *)vsllink_usb_in_buffer
, vsllink_buffer_size
,
1020 VSLLINK_USB_TIMEOUT
);
1022 DEBUG_JTAG_IO("vsllink_usb_read, result = %d", result
);
1024 #ifdef _DEBUG_USB_COMMS_
1025 LOG_DEBUG("USB in:");
1026 vsllink_debug_buffer(vsllink_usb_in_buffer
, result
);
1031 #define BYTES_PER_LINE 16
1033 #if defined _DEBUG_USB_COMMS_ || defined _DEBUG_JTAG_IO_
1034 static void vsllink_debug_buffer(uint8_t *buffer
, int length
)
1041 for (i
= 0; i
< length
; i
+= BYTES_PER_LINE
) {
1042 snprintf(line
, 5, "%04x", i
);
1043 for (j
= i
; j
< i
+ BYTES_PER_LINE
&& j
< length
; j
++) {
1044 snprintf(s
, 4, " %02x", buffer
[j
]);
1047 LOG_DEBUG("%s", line
);
1050 #endif /* _DEBUG_USB_COMMS_ || _DEBUG_JTAG_IO_ */
1052 static const struct command_registration vsllink_command_handlers
[] = {
1054 .name
= "vsllink_usb_vid",
1055 .handler
= &vsllink_handle_usb_vid_command
,
1056 .mode
= COMMAND_CONFIG
,
1059 .name
= "vsllink_usb_pid",
1060 .handler
= &vsllink_handle_usb_pid_command
,
1061 .mode
= COMMAND_CONFIG
,
1064 .name
= "vsllink_usb_bulkin",
1065 .handler
= &vsllink_handle_usb_bulkin_command
,
1066 .mode
= COMMAND_CONFIG
,
1069 .name
= "vsllink_usb_bulkout",
1070 .handler
= &vsllink_handle_usb_bulkout_command
,
1071 .mode
= COMMAND_CONFIG
,
1074 .name
= "vsllink_usb_interface",
1075 .handler
= &vsllink_handle_usb_interface_command
,
1076 .mode
= COMMAND_CONFIG
,
1079 .name
= "vsllink_mode",
1080 .handler
= &vsllink_handle_mode_command
,
1081 .mode
= COMMAND_CONFIG
,
1083 COMMAND_REGISTRATION_DONE
1086 struct jtag_interface vsllink_interface
= {
1088 .commands
= vsllink_command_handlers
,
1090 .init
= vsllink_init
,
1091 .quit
= vsllink_quit
,
1093 .speed
= vsllink_speed
,
1094 .speed_div
= vsllink_speed_div
,
1095 .execute_queue
= vsllink_execute_queue
,
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)