1 /***************************************************************************
2 * Copyright (C) 2005 by Dominic Rath *
3 * Dominic.Rath@gmx.de *
5 * Copyright (C) 2007-2009 Øyvind Harboe *
6 * oyvind.harboe@zylin.com *
8 * Copyright (C) 2009 SoftPLC Corporation *
12 * Copyright (C) 2009 Zachary T Welch *
13 * zw@superlucidity.net *
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, write to the *
27 * Free Software Foundation, Inc., *
28 * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
29 ***************************************************************************/
34 #include <jtag/jtag.h>
35 #include <jtag/interface.h>
36 #include <jtag/commands.h>
37 #include <jtag/minidriver.h>
38 #include <helper/command.h>
40 struct jtag_callback_entry
42 struct jtag_callback_entry
*next
;
44 jtag_callback_t callback
;
45 jtag_callback_data_t data0
;
46 jtag_callback_data_t data1
;
47 jtag_callback_data_t data2
;
48 jtag_callback_data_t data3
;
51 static struct jtag_callback_entry
*jtag_callback_queue_head
= NULL
;
52 static struct jtag_callback_entry
*jtag_callback_queue_tail
= NULL
;
54 static void jtag_callback_queue_reset(void)
56 jtag_callback_queue_head
= NULL
;
57 jtag_callback_queue_tail
= NULL
;
61 * Copy a struct scan_field for insertion into the queue.
63 * This allocates a new copy of out_value using cmd_queue_alloc.
65 static void cmd_queue_scan_field_clone(struct scan_field
* dst
, const struct scan_field
* src
)
68 dst
->num_bits
= src
->num_bits
;
69 dst
->out_value
= buf_cpy(src
->out_value
, cmd_queue_alloc(DIV_ROUND_UP(src
->num_bits
, 8)), src
->num_bits
);
70 dst
->in_value
= src
->in_value
;
75 * see jtag_add_ir_scan()
78 int interface_jtag_add_ir_scan(int in_num_fields
, const struct scan_field
*in_fields
, tap_state_t state
)
80 size_t num_taps
= jtag_tap_count_enabled();
82 struct jtag_command
* cmd
= cmd_queue_alloc(sizeof(struct jtag_command
));
83 struct scan_command
* scan
= cmd_queue_alloc(sizeof(struct scan_command
));
84 struct scan_field
* out_fields
= cmd_queue_alloc(num_taps
* sizeof(struct scan_field
));
86 jtag_queue_command(cmd
);
88 cmd
->type
= JTAG_SCAN
;
92 scan
->num_fields
= num_taps
; /* one field per device */
93 scan
->fields
= out_fields
;
94 scan
->end_state
= state
;
97 struct scan_field
* field
= out_fields
; /* keep track where we insert data */
99 /* loop over all enabled TAPs */
101 for (struct jtag_tap
* tap
= jtag_tap_next_enabled(NULL
); tap
!= NULL
; tap
= jtag_tap_next_enabled(tap
))
103 /* search the input field list for fields for the current TAP */
107 for (int j
= 0; j
< in_num_fields
; j
++)
109 if (tap
!= in_fields
[j
].tap
)
112 /* if TAP is listed in input fields, copy the value */
118 assert(in_fields
[j
].num_bits
== tap
->ir_length
); /* input fields must have the same length as the TAP's IR */
120 cmd_queue_scan_field_clone(field
, in_fields
+ j
);
127 /* if a TAP isn't listed in input fields, set it to BYPASS */
132 field
->num_bits
= tap
->ir_length
;
133 field
->out_value
= buf_set_ones(cmd_queue_alloc(DIV_ROUND_UP(tap
->ir_length
, 8)), tap
->ir_length
);
134 field
->in_value
= NULL
; /* do not collect input for tap's in bypass */
137 /* update device information */
138 buf_cpy(field
->out_value
, tap
->cur_instr
, tap
->ir_length
);
143 assert(field
== out_fields
+ num_taps
); /* paranoia: jtag_tap_count_enabled() and jtag_tap_next_enabled() not in sync */
149 * see jtag_add_plain_ir_scan()
152 int interface_jtag_add_plain_ir_scan(int in_num_fields
, const struct scan_field
*in_fields
, tap_state_t state
)
155 struct jtag_command
* cmd
= cmd_queue_alloc(sizeof(struct jtag_command
));
156 struct scan_command
* scan
= cmd_queue_alloc(sizeof(struct scan_command
));
157 struct scan_field
* out_fields
= cmd_queue_alloc(in_num_fields
* sizeof(struct scan_field
));
159 jtag_queue_command(cmd
);
161 cmd
->type
= JTAG_SCAN
;
162 cmd
->cmd
.scan
= scan
;
164 scan
->ir_scan
= true;
165 scan
->num_fields
= in_num_fields
;
166 scan
->fields
= out_fields
;
167 scan
->end_state
= state
;
169 for (int i
= 0; i
< in_num_fields
; i
++)
170 cmd_queue_scan_field_clone(out_fields
+ i
, in_fields
+ i
);
178 * see jtag_add_dr_scan()
181 int interface_jtag_add_dr_scan(int in_num_fields
, const struct scan_field
*in_fields
, tap_state_t state
)
183 /* count devices in bypass */
185 size_t bypass_devices
= 0;
187 for (struct jtag_tap
* tap
= jtag_tap_next_enabled(NULL
); tap
!= NULL
; tap
= jtag_tap_next_enabled(tap
))
193 struct jtag_command
* cmd
= cmd_queue_alloc(sizeof(struct jtag_command
));
194 struct scan_command
* scan
= cmd_queue_alloc(sizeof(struct scan_command
));
195 struct scan_field
* out_fields
= cmd_queue_alloc((in_num_fields
+ bypass_devices
) * sizeof(struct scan_field
));
197 jtag_queue_command(cmd
);
199 cmd
->type
= JTAG_SCAN
;
200 cmd
->cmd
.scan
= scan
;
202 scan
->ir_scan
= false;
203 scan
->num_fields
= in_num_fields
+ bypass_devices
;
204 scan
->fields
= out_fields
;
205 scan
->end_state
= state
;
208 struct scan_field
* field
= out_fields
; /* keep track where we insert data */
210 /* loop over all enabled TAPs */
212 for (struct jtag_tap
* tap
= jtag_tap_next_enabled(NULL
); tap
!= NULL
; tap
= jtag_tap_next_enabled(tap
))
214 /* if TAP is not bypassed insert matching input fields */
219 /* remember initial position for assert() */
220 struct scan_field
*start_field
= field
;
223 for (int j
= 0; j
< in_num_fields
; j
++)
225 if (tap
!= in_fields
[j
].tap
)
228 cmd_queue_scan_field_clone(field
, in_fields
+ j
);
233 assert(field
> start_field
); /* must have at least one input field per not bypassed TAP */
236 /* if a TAP is bypassed, generated a dummy bit*/
241 field
->out_value
= NULL
;
242 field
->in_value
= NULL
;
248 assert(field
== out_fields
+ scan
->num_fields
); /* no superfluous input fields permitted */
256 * Generate a DR SCAN using the array of output values passed to the function
258 * This function assumes that the parameter target_tap specifies the one TAP
259 * that is not bypassed. All other TAPs must be bypassed and the function will
260 * generate a dummy 1bit field for them.
262 * For the target_tap a sequence of output-only fields will be generated where
263 * each field has the size num_bits and the field's values are taken from
266 * The bypass status of TAPs is set by jtag_add_ir_scan().
269 void interface_jtag_add_dr_out(struct jtag_tap
*target_tap
,
272 const uint32_t *value
,
273 tap_state_t end_state
)
275 /* count devices in bypass */
277 size_t bypass_devices
= 0;
279 for (struct jtag_tap
* tap
= jtag_tap_next_enabled(NULL
); tap
!= NULL
; tap
= jtag_tap_next_enabled(tap
))
286 struct jtag_command
* cmd
= cmd_queue_alloc(sizeof(struct jtag_command
));
287 struct scan_command
* scan
= cmd_queue_alloc(sizeof(struct scan_command
));
288 struct scan_field
* out_fields
= cmd_queue_alloc((in_num_fields
+ bypass_devices
) * sizeof(struct scan_field
));
290 jtag_queue_command(cmd
);
292 cmd
->type
= JTAG_SCAN
;
293 cmd
->cmd
.scan
= scan
;
295 scan
->ir_scan
= false;
296 scan
->num_fields
= in_num_fields
+ bypass_devices
;
297 scan
->fields
= out_fields
;
298 scan
->end_state
= end_state
;
301 bool target_tap_match
= false;
303 struct scan_field
* field
= out_fields
; /* keep track where we insert data */
305 /* loop over all enabled TAPs */
307 for (struct jtag_tap
* tap
= jtag_tap_next_enabled(NULL
); tap
!= NULL
; tap
= jtag_tap_next_enabled(tap
))
309 /* if TAP is not bypassed insert matching input fields */
313 assert(tap
== target_tap
); /* target_tap must match the one not bypassed TAP */
315 target_tap_match
= true;
317 for (int j
= 0; j
< in_num_fields
; j
++)
319 uint8_t out_value
[4];
320 size_t scan_size
= num_bits
[j
];
321 buf_set_u32(out_value
, 0, scan_size
, value
[j
]);
324 field
->num_bits
= scan_size
;
325 field
->out_value
= buf_cpy(out_value
, cmd_queue_alloc(DIV_ROUND_UP(scan_size
, 8)), scan_size
);
326 field
->in_value
= NULL
;
332 /* if a TAP is bypassed, generated a dummy bit*/
338 field
->out_value
= NULL
;
339 field
->in_value
= NULL
;
345 assert(target_tap_match
); /* target_tap should be enabled and not bypassed */
349 * see jtag_add_plain_dr_scan()
352 int interface_jtag_add_plain_dr_scan(int in_num_fields
, const struct scan_field
*in_fields
, tap_state_t state
)
354 struct jtag_command
* cmd
= cmd_queue_alloc(sizeof(struct jtag_command
));
355 struct scan_command
* scan
= cmd_queue_alloc(sizeof(struct scan_command
));
356 struct scan_field
* out_fields
= cmd_queue_alloc(in_num_fields
* sizeof(struct scan_field
));
358 jtag_queue_command(cmd
);
360 cmd
->type
= JTAG_SCAN
;
361 cmd
->cmd
.scan
= scan
;
363 scan
->ir_scan
= false;
364 scan
->num_fields
= in_num_fields
;
365 scan
->fields
= out_fields
;
366 scan
->end_state
= state
;
368 for (int i
= 0; i
< in_num_fields
; i
++)
369 cmd_queue_scan_field_clone(out_fields
+ i
, in_fields
+ i
);
374 int interface_jtag_add_tlr(void)
376 tap_state_t state
= TAP_RESET
;
378 /* allocate memory for a new list member */
379 struct jtag_command
* cmd
= cmd_queue_alloc(sizeof(struct jtag_command
));
381 jtag_queue_command(cmd
);
383 cmd
->type
= JTAG_STATEMOVE
;
385 cmd
->cmd
.statemove
= cmd_queue_alloc(sizeof(struct statemove_command
));
386 cmd
->cmd
.statemove
->end_state
= state
;
391 int interface_add_tms_seq(unsigned num_bits
, const uint8_t *seq
)
393 struct jtag_command
*cmd
;
395 cmd
= cmd_queue_alloc(sizeof(struct jtag_command
));
399 cmd
->type
= JTAG_TMS
;
400 cmd
->cmd
.tms
= cmd_queue_alloc(sizeof(*cmd
->cmd
.tms
));
404 /* copy the bits; our caller doesn't guarantee they'll persist */
405 cmd
->cmd
.tms
->num_bits
= num_bits
;
406 cmd
->cmd
.tms
->bits
= buf_cpy(seq
,
407 cmd_queue_alloc(DIV_ROUND_UP(num_bits
, 8)), num_bits
);
408 if (!cmd
->cmd
.tms
->bits
)
411 jtag_queue_command(cmd
);
416 int interface_jtag_add_pathmove(int num_states
, const tap_state_t
*path
)
418 /* allocate memory for a new list member */
419 struct jtag_command
* cmd
= cmd_queue_alloc(sizeof(struct jtag_command
));
421 jtag_queue_command(cmd
);
423 cmd
->type
= JTAG_PATHMOVE
;
425 cmd
->cmd
.pathmove
= cmd_queue_alloc(sizeof(struct pathmove_command
));
426 cmd
->cmd
.pathmove
->num_states
= num_states
;
427 cmd
->cmd
.pathmove
->path
= cmd_queue_alloc(sizeof(tap_state_t
) * num_states
);
429 for (int i
= 0; i
< num_states
; i
++)
430 cmd
->cmd
.pathmove
->path
[i
] = path
[i
];
435 int interface_jtag_add_runtest(int num_cycles
, tap_state_t state
)
437 /* allocate memory for a new list member */
438 struct jtag_command
* cmd
= cmd_queue_alloc(sizeof(struct jtag_command
));
440 jtag_queue_command(cmd
);
442 cmd
->type
= JTAG_RUNTEST
;
444 cmd
->cmd
.runtest
= cmd_queue_alloc(sizeof(struct runtest_command
));
445 cmd
->cmd
.runtest
->num_cycles
= num_cycles
;
446 cmd
->cmd
.runtest
->end_state
= state
;
451 int interface_jtag_add_clocks(int num_cycles
)
453 /* allocate memory for a new list member */
454 struct jtag_command
* cmd
= cmd_queue_alloc(sizeof(struct jtag_command
));
456 jtag_queue_command(cmd
);
458 cmd
->type
= JTAG_STABLECLOCKS
;
460 cmd
->cmd
.stableclocks
= cmd_queue_alloc(sizeof(struct stableclocks_command
));
461 cmd
->cmd
.stableclocks
->num_cycles
= num_cycles
;
466 int interface_jtag_add_reset(int req_trst
, int req_srst
)
468 /* allocate memory for a new list member */
469 struct jtag_command
* cmd
= cmd_queue_alloc(sizeof(struct jtag_command
));
471 jtag_queue_command(cmd
);
473 cmd
->type
= JTAG_RESET
;
475 cmd
->cmd
.reset
= cmd_queue_alloc(sizeof(struct reset_command
));
476 cmd
->cmd
.reset
->trst
= req_trst
;
477 cmd
->cmd
.reset
->srst
= req_srst
;
482 int interface_jtag_add_sleep(uint32_t us
)
484 /* allocate memory for a new list member */
485 struct jtag_command
* cmd
= cmd_queue_alloc(sizeof(struct jtag_command
));
487 jtag_queue_command(cmd
);
489 cmd
->type
= JTAG_SLEEP
;
491 cmd
->cmd
.sleep
= cmd_queue_alloc(sizeof(struct sleep_command
));
492 cmd
->cmd
.sleep
->us
= us
;
497 /* add callback to end of queue */
498 void interface_jtag_add_callback4(jtag_callback_t callback
, jtag_callback_data_t data0
, jtag_callback_data_t data1
, jtag_callback_data_t data2
, jtag_callback_data_t data3
)
500 struct jtag_callback_entry
*entry
= cmd_queue_alloc(sizeof(struct jtag_callback_entry
));
503 entry
->callback
= callback
;
504 entry
->data0
= data0
;
505 entry
->data1
= data1
;
506 entry
->data2
= data2
;
507 entry
->data3
= data3
;
509 if (jtag_callback_queue_head
== NULL
)
511 jtag_callback_queue_head
= entry
;
512 jtag_callback_queue_tail
= entry
;
515 jtag_callback_queue_tail
->next
= entry
;
516 jtag_callback_queue_tail
= entry
;
520 int interface_jtag_execute_queue(void)
522 static int reentry
= 0;
527 int retval
= default_interface_jtag_execute_queue();
528 if (retval
== ERROR_OK
)
530 struct jtag_callback_entry
*entry
;
531 for (entry
= jtag_callback_queue_head
; entry
!= NULL
; entry
= entry
->next
)
533 retval
= entry
->callback(entry
->data0
, entry
->data1
, entry
->data2
, entry
->data3
);
534 if (retval
!= ERROR_OK
)
539 jtag_command_queue_reset();
540 jtag_callback_queue_reset();
547 static int jtag_convert_to_callback4(jtag_callback_data_t data0
, jtag_callback_data_t data1
, jtag_callback_data_t data2
, jtag_callback_data_t data3
)
549 ((jtag_callback1_t
)data1
)(data0
);
553 void interface_jtag_add_callback(jtag_callback1_t callback
, jtag_callback_data_t data0
)
555 jtag_add_callback4(jtag_convert_to_callback4
, data0
, (jtag_callback_data_t
)callback
, 0, 0);
559 /* A minidriver can use use an inline versions of this API level fn */
560 void jtag_add_dr_out(struct jtag_tap
* tap
,
561 int num_fields
, const int* num_bits
, const uint32_t* value
,
562 tap_state_t end_state
)
564 assert(end_state
!= TAP_RESET
);
565 assert(end_state
!= TAP_INVALID
);
567 cmd_queue_cur_state
= end_state
;
569 interface_jtag_add_dr_out(tap
,
570 num_fields
, num_bits
, value
,
574 void jtag_add_callback(jtag_callback1_t f
, jtag_callback_data_t data0
)
576 interface_jtag_add_callback(f
, data0
);
579 void jtag_add_callback4(jtag_callback_t f
, jtag_callback_data_t data0
,
580 jtag_callback_data_t data1
, jtag_callback_data_t data2
,
581 jtag_callback_data_t data3
)
583 interface_jtag_add_callback4(f
, data0
, data1
, data2
, data3
);
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)