4 * Copyright (C) 2013 Franck Jullien, <elec4fun@gmail.com>
6 * See file CREDITS for list of people who contributed to this
9 * This program is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU General Public License as
11 * published by the Free Software Foundation; either version 2 of
12 * the License, or (at your option) any later version.
14 * This program is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU General Public License for more details.
19 * You should have received a copy of the GNU General Public License
20 * along with this program. If not, see <http://www.gnu.org/licenses/>.
27 #include <jtag/interface.h>
28 #ifdef HAVE_ARPA_INET_H
29 #include <arpa/inet.h>
33 #include <netinet/tcp.h>
36 #define NO_TAP_SHIFT 0
39 #define SERVER_ADDRESS "127.0.0.1"
40 #define SERVER_PORT 5555
42 #define XFERT_MAX_SIZE 512
46 #define CMD_SCAN_CHAIN 2
47 #define CMD_SCAN_CHAIN_FLIP_TMS 3
48 #define CMD_STOP_SIMU 4
50 int server_port
= SERVER_PORT
;
54 struct sockaddr_in serv_addr
;
56 /* One jtag_vpi "packet" as sent over a TCP channel. */
60 unsigned char cmd_buf
[4];
62 unsigned char buffer_out
[XFERT_MAX_SIZE
];
63 unsigned char buffer_in
[XFERT_MAX_SIZE
];
66 unsigned char length_buf
[4];
70 unsigned char nb_bits_buf
[4];
74 static int jtag_vpi_send_cmd(struct vpi_cmd
*vpi
)
76 /* Use little endian when transmitting/receiving jtag_vpi cmds.
77 The choice of little endian goes against usual networking conventions
78 but is intentional to remain compatible with most older OpenOCD builds
79 (i.e. builds on little-endian platforms). */
80 h_u32_to_le(vpi
->cmd_buf
, vpi
->cmd
);
81 h_u32_to_le(vpi
->length_buf
, vpi
->length
);
82 h_u32_to_le(vpi
->nb_bits_buf
, vpi
->nb_bits
);
84 int retval
= write_socket(sockfd
, vpi
, sizeof(struct vpi_cmd
));
91 static int jtag_vpi_receive_cmd(struct vpi_cmd
*vpi
)
93 int retval
= read_socket(sockfd
, vpi
, sizeof(struct vpi_cmd
));
94 if (retval
< (int)sizeof(struct vpi_cmd
))
97 /* Use little endian when transmitting/receiving jtag_vpi cmds. */
98 vpi
->cmd
= le_to_h_u32(vpi
->cmd_buf
);
99 vpi
->length
= le_to_h_u32(vpi
->length_buf
);
100 vpi
->nb_bits
= le_to_h_u32(vpi
->nb_bits_buf
);
106 * jtag_vpi_reset - ask to reset the JTAG device
107 * @trst: 1 if TRST is to be asserted
108 * @srst: 1 if SRST is to be asserted
110 static int jtag_vpi_reset(int trst
, int srst
)
116 return jtag_vpi_send_cmd(&vpi
);
120 * jtag_vpi_tms_seq - ask a TMS sequence transition to JTAG
121 * @bits: TMS bits to be written (bit0, bit1 .. bitN)
122 * @nb_bits: number of TMS bits (between 1 and 8)
124 * Write a serie of TMS transitions, where each transition consists in :
125 * - writing out TCK=0, TMS=<new_state>, TDI=<???>
126 * - writing out TCK=1, TMS=<new_state>, TDI=<???> which triggers the transition
127 * The function ensures that at the end of the sequence, the clock (TCK) is put
130 static int jtag_vpi_tms_seq(const uint8_t *bits
, int nb_bits
)
135 nb_bytes
= DIV_ROUND_UP(nb_bits
, 8);
137 vpi
.cmd
= CMD_TMS_SEQ
;
138 memcpy(vpi
.buffer_out
, bits
, nb_bytes
);
139 vpi
.length
= nb_bytes
;
140 vpi
.nb_bits
= nb_bits
;
142 return jtag_vpi_send_cmd(&vpi
);
146 * jtag_vpi_path_move - ask a TMS sequence transition to JTAG
147 * @cmd: path transition
149 * Write a serie of TMS transitions, where each transition consists in :
150 * - writing out TCK=0, TMS=<new_state>, TDI=<???>
151 * - writing out TCK=1, TMS=<new_state>, TDI=<???> which triggers the transition
152 * The function ensures that at the end of the sequence, the clock (TCK) is put
156 static int jtag_vpi_path_move(struct pathmove_command
*cmd
)
158 uint8_t trans
[DIV_ROUND_UP(cmd
->num_states
, 8)];
160 memset(trans
, 0, DIV_ROUND_UP(cmd
->num_states
, 8));
162 for (int i
= 0; i
< cmd
->num_states
; i
++) {
163 if (tap_state_transition(tap_get_state(), true) == cmd
->path
[i
])
164 buf_set_u32(trans
, i
, 1, 1);
165 tap_set_state(cmd
->path
[i
]);
168 return jtag_vpi_tms_seq(trans
, cmd
->num_states
);
172 * jtag_vpi_tms - ask a tms command
175 static int jtag_vpi_tms(struct tms_command
*cmd
)
177 return jtag_vpi_tms_seq(cmd
->bits
, cmd
->num_bits
);
180 static int jtag_vpi_state_move(tap_state_t state
)
182 if (tap_get_state() == state
)
185 uint8_t tms_scan
= tap_get_tms_path(tap_get_state(), state
);
186 int tms_len
= tap_get_tms_path_len(tap_get_state(), state
);
188 int retval
= jtag_vpi_tms_seq(&tms_scan
, tms_len
);
189 if (retval
!= ERROR_OK
)
192 tap_set_state(state
);
197 static int jtag_vpi_queue_tdi_xfer(uint8_t *bits
, int nb_bits
, int tap_shift
)
200 int nb_bytes
= DIV_ROUND_UP(nb_bits
, 8);
202 vpi
.cmd
= tap_shift
? CMD_SCAN_CHAIN_FLIP_TMS
: CMD_SCAN_CHAIN
;
205 memcpy(vpi
.buffer_out
, bits
, nb_bytes
);
207 memset(vpi
.buffer_out
, 0xff, nb_bytes
);
209 vpi
.length
= nb_bytes
;
210 vpi
.nb_bits
= nb_bits
;
212 int retval
= jtag_vpi_send_cmd(&vpi
);
213 if (retval
!= ERROR_OK
)
216 retval
= jtag_vpi_receive_cmd(&vpi
);
217 if (retval
!= ERROR_OK
)
221 memcpy(bits
, vpi
.buffer_in
, nb_bytes
);
227 * jtag_vpi_queue_tdi - short description
228 * @bits: bits to be queued on TDI (or NULL if 0 are to be queued)
229 * @nb_bits: number of bits
231 static int jtag_vpi_queue_tdi(uint8_t *bits
, int nb_bits
, int tap_shift
)
233 int nb_xfer
= DIV_ROUND_UP(nb_bits
, XFERT_MAX_SIZE
* 8);
238 retval
= jtag_vpi_queue_tdi_xfer(bits
, nb_bits
, tap_shift
);
239 if (retval
!= ERROR_OK
)
242 retval
= jtag_vpi_queue_tdi_xfer(bits
, XFERT_MAX_SIZE
* 8, NO_TAP_SHIFT
);
243 if (retval
!= ERROR_OK
)
245 nb_bits
-= XFERT_MAX_SIZE
* 8;
247 bits
+= XFERT_MAX_SIZE
;
257 * jtag_vpi_clock_tms - clock a TMS transition
258 * @tms: the TMS to be sent
260 * Triggers a TMS transition (ie. one JTAG TAP state move).
262 static int jtag_vpi_clock_tms(int tms
)
264 const uint8_t tms_0
= 0;
265 const uint8_t tms_1
= 1;
267 return jtag_vpi_tms_seq(tms
? &tms_1
: &tms_0
, 1);
271 * jtag_vpi_scan - launches a DR-scan or IR-scan
272 * @cmd: the command to launch
274 * Launch a JTAG IR-scan or DR-scan
276 * Returns ERROR_OK if OK, ERROR_xxx if a read/write error occured.
278 static int jtag_vpi_scan(struct scan_command
*cmd
)
282 int retval
= ERROR_OK
;
284 scan_bits
= jtag_build_buffer(cmd
, &buf
);
287 retval
= jtag_vpi_state_move(TAP_IRSHIFT
);
288 if (retval
!= ERROR_OK
)
291 retval
= jtag_vpi_state_move(TAP_DRSHIFT
);
292 if (retval
!= ERROR_OK
)
296 if (cmd
->end_state
== TAP_DRSHIFT
) {
297 retval
= jtag_vpi_queue_tdi(buf
, scan_bits
, NO_TAP_SHIFT
);
298 if (retval
!= ERROR_OK
)
301 retval
= jtag_vpi_queue_tdi(buf
, scan_bits
, TAP_SHIFT
);
302 if (retval
!= ERROR_OK
)
306 if (cmd
->end_state
!= TAP_DRSHIFT
) {
308 * As our JTAG is in an unstable state (IREXIT1 or DREXIT1), move it
309 * forward to a stable IRPAUSE or DRPAUSE.
311 retval
= jtag_vpi_clock_tms(0);
312 if (retval
!= ERROR_OK
)
316 tap_set_state(TAP_IRPAUSE
);
318 tap_set_state(TAP_DRPAUSE
);
321 retval
= jtag_read_buffer(buf
, cmd
);
322 if (retval
!= ERROR_OK
)
328 if (cmd
->end_state
!= TAP_DRSHIFT
) {
329 retval
= jtag_vpi_state_move(cmd
->end_state
);
330 if (retval
!= ERROR_OK
)
337 static int jtag_vpi_runtest(int cycles
, tap_state_t state
)
341 retval
= jtag_vpi_state_move(TAP_IDLE
);
342 if (retval
!= ERROR_OK
)
345 retval
= jtag_vpi_queue_tdi(NULL
, cycles
, NO_TAP_SHIFT
);
346 if (retval
!= ERROR_OK
)
349 return jtag_vpi_state_move(state
);
352 static int jtag_vpi_stableclocks(int cycles
)
355 int cycles_remain
= cycles
;
358 const int CYCLES_ONE_BATCH
= sizeof(tms_bits
) * 8;
362 /* use TMS=1 in TAP RESET state, TMS=0 in all other stable states */
363 memset(&tms_bits
, (tap_get_state() == TAP_RESET
) ? 0xff : 0x00, sizeof(tms_bits
));
365 /* send the TMS bits */
366 while (cycles_remain
> 0) {
367 nb_bits
= (cycles_remain
< CYCLES_ONE_BATCH
) ? cycles_remain
: CYCLES_ONE_BATCH
;
368 retval
= jtag_vpi_tms_seq(tms_bits
, nb_bits
);
369 if (retval
!= ERROR_OK
)
371 cycles_remain
-= nb_bits
;
377 static int jtag_vpi_execute_queue(void)
379 struct jtag_command
*cmd
;
380 int retval
= ERROR_OK
;
382 for (cmd
= jtag_command_queue
; retval
== ERROR_OK
&& cmd
!= NULL
;
386 retval
= jtag_vpi_reset(cmd
->cmd
.reset
->trst
, cmd
->cmd
.reset
->srst
);
389 retval
= jtag_vpi_runtest(cmd
->cmd
.runtest
->num_cycles
,
390 cmd
->cmd
.runtest
->end_state
);
392 case JTAG_STABLECLOCKS
:
393 retval
= jtag_vpi_stableclocks(cmd
->cmd
.stableclocks
->num_cycles
);
396 retval
= jtag_vpi_state_move(cmd
->cmd
.statemove
->end_state
);
399 retval
= jtag_vpi_path_move(cmd
->cmd
.pathmove
);
402 retval
= jtag_vpi_tms(cmd
->cmd
.tms
);
405 jtag_sleep(cmd
->cmd
.sleep
->us
);
408 retval
= jtag_vpi_scan(cmd
->cmd
.scan
);
411 LOG_ERROR("BUG: unknown JTAG command type 0x%X",
421 static int jtag_vpi_init(void)
425 sockfd
= socket(AF_INET
, SOCK_STREAM
, 0);
427 LOG_ERROR("Could not create socket");
431 memset(&serv_addr
, 0, sizeof(serv_addr
));
433 serv_addr
.sin_family
= AF_INET
;
434 serv_addr
.sin_port
= htons(server_port
);
437 server_address
= strdup(SERVER_ADDRESS
);
439 serv_addr
.sin_addr
.s_addr
= inet_addr(server_address
);
441 if (serv_addr
.sin_addr
.s_addr
== INADDR_NONE
) {
442 LOG_ERROR("inet_addr error occured");
446 if (connect(sockfd
, (struct sockaddr
*)&serv_addr
, sizeof(serv_addr
)) < 0) {
448 LOG_ERROR("Can't connect to %s : %u", server_address
, server_port
);
449 return ERROR_COMMAND_CLOSE_CONNECTION
;
452 if (serv_addr
.sin_addr
.s_addr
== htonl(INADDR_LOOPBACK
)) {
453 /* This increases performance drematically for local
454 * connections, which is the most likely arrangement
455 * for a VPI connection. */
456 setsockopt(sockfd
, IPPROTO_TCP
, TCP_NODELAY
, (char *)&flag
, sizeof(int));
459 LOG_INFO("Connection to %s : %u succeed", server_address
, server_port
);
464 static int jtag_vpi_quit(void)
466 free(server_address
);
467 return close(sockfd
);
470 COMMAND_HANDLER(jtag_vpi_set_port
)
473 LOG_WARNING("You need to set a port number");
475 COMMAND_PARSE_NUMBER(int, CMD_ARGV
[0], server_port
);
477 LOG_INFO("Set server port to %u", server_port
);
482 COMMAND_HANDLER(jtag_vpi_set_address
)
484 free(server_address
);
487 LOG_WARNING("You need to set an address");
488 server_address
= strdup(SERVER_ADDRESS
);
490 server_address
= strdup(CMD_ARGV
[0]);
492 LOG_INFO("Set server address to %s", server_address
);
497 static const struct command_registration jtag_vpi_command_handlers
[] = {
499 .name
= "jtag_vpi_set_port",
500 .handler
= &jtag_vpi_set_port
,
501 .mode
= COMMAND_CONFIG
,
502 .help
= "set the port of the VPI server",
503 .usage
= "description_string",
506 .name
= "jtag_vpi_set_address",
507 .handler
= &jtag_vpi_set_address
,
508 .mode
= COMMAND_CONFIG
,
509 .help
= "set the address of the VPI server",
510 .usage
= "description_string",
512 COMMAND_REGISTRATION_DONE
515 struct jtag_interface jtag_vpi_interface
= {
517 .supported
= DEBUG_CAP_TMS_SEQ
,
518 .commands
= jtag_vpi_command_handlers
,
519 .transports
= jtag_only
,
521 .init
= jtag_vpi_init
,
522 .quit
= jtag_vpi_quit
,
523 .execute_queue
= jtag_vpi_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)