1 /***************************************************************************
2 * Copyright (C) 2005 by Dominic Rath *
3 * Dominic.Rath@gmx.de *
5 * Copyright (C) 2007,2008 Ø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 ***************************************************************************/
35 #include "minidriver.h"
36 #include "interface.h"
43 /// The number of JTAG queue flushes (for profiling and debugging purposes).
44 static int jtag_flush_queue_count
;
46 static void jtag_add_scan_check(void (*jtag_add_scan
)(int in_num_fields
, const scan_field_t
*in_fields
, tap_state_t state
),
47 int in_num_fields
, scan_field_t
*in_fields
, tap_state_t state
);
50 * The jtag_error variable is set when an error occurs while executing
51 * the queue. Application code may set this using jtag_set_error(),
52 * when an error occurs during processing that should be reported during
53 * jtag_execute_queue().
55 * Tts value may be checked with jtag_get_error() and cleared with
56 * jtag_error_clear(). This value is returned (and cleared) by
57 * jtag_execute_queue().
59 static int jtag_error
= ERROR_OK
;
61 static char* jtag_event_strings
[] =
63 "JTAG controller reset (RESET or TRST)"
66 const Jim_Nvp nvp_jtag_tap_event
[] = {
67 { .value
= JTAG_TAP_EVENT_ENABLE
, .name
= "tap-enable" },
68 { .value
= JTAG_TAP_EVENT_DISABLE
, .name
= "tap-disable" },
70 { .name
= NULL
, .value
= -1 }
73 static int jtag_trst
= 0;
74 static int jtag_srst
= 0;
77 * List all TAPs that have been created.
79 static jtag_tap_t
*__jtag_all_taps
= NULL
;
81 * The number of TAPs in the __jtag_all_taps list, used to track the
82 * assigned chain position to new TAPs
84 static unsigned jtag_num_taps
= 0;
86 static enum reset_types jtag_reset_config
= RESET_NONE
;
87 static tap_state_t cmd_queue_end_state
= TAP_RESET
;
88 tap_state_t cmd_queue_cur_state
= TAP_RESET
;
90 static bool jtag_verify_capture_ir
= true;
91 static int jtag_verify
= 1;
93 /* how long the OpenOCD should wait before attempting JTAG communication after reset lines deasserted (in ms) */
94 static int jtag_nsrst_delay
= 0; /* default to no nSRST delay */
95 static int jtag_ntrst_delay
= 0; /* default to no nTRST delay */
97 /* callbacks to inform high-level handlers about JTAG state changes */
98 static jtag_event_callback_t
*jtag_event_callbacks
;
101 static int speed_khz
= 0;
102 /* flag if the kHz speed was defined */
103 static bool hasKHz
= false;
104 static int jtag_speed
= 0;
106 struct jtag_interface_s
*jtag
= NULL
;
109 jtag_interface_t
*jtag_interface
= NULL
;
111 void jtag_set_error(int error
)
113 if ((error
== ERROR_OK
) || (jtag_error
!= ERROR_OK
))
117 int jtag_get_error(void)
121 int jtag_error_clear(void)
123 int temp
= jtag_error
;
124 jtag_error
= ERROR_OK
;
129 jtag_tap_t
*jtag_all_taps(void)
131 return __jtag_all_taps
;
134 unsigned jtag_tap_count(void)
136 return jtag_num_taps
;
139 unsigned jtag_tap_count_enabled(void)
141 jtag_tap_t
*t
= jtag_all_taps();
152 /// Append a new TAP to the chain of all taps.
153 void jtag_tap_add(struct jtag_tap_s
*t
)
155 t
->abs_chain_position
= jtag_num_taps
++;
157 jtag_tap_t
**tap
= &__jtag_all_taps
;
159 tap
= &(*tap
)->next_tap
;
163 jtag_tap_t
*jtag_tap_by_string(const char *s
)
165 /* try by name first */
166 jtag_tap_t
*t
= jtag_all_taps();
169 if (0 == strcmp(t
->dotted_name
, s
))
174 /* no tap found by name, so try to parse the name as a number */
176 unsigned n
= strtoul(s
, &cp
, 0);
177 if ((s
== cp
) || (*cp
!= 0))
180 return jtag_tap_by_position(n
);
183 jtag_tap_t
*jtag_tap_by_jim_obj(Jim_Interp
*interp
, Jim_Obj
*o
)
185 const char *cp
= Jim_GetString(o
, NULL
);
186 jtag_tap_t
*t
= cp
? jtag_tap_by_string(cp
) : NULL
;
190 Jim_SetResult_sprintf(interp
, "Tap '%s' could not be found", cp
);
194 /* returns a pointer to the n-th device in the scan chain */
195 jtag_tap_t
*jtag_tap_by_position(unsigned n
)
197 jtag_tap_t
*t
= jtag_all_taps();
205 const char *jtag_tap_name(const jtag_tap_t
*tap
)
207 return (tap
== NULL
) ? "(unknown)" : tap
->dotted_name
;
211 int jtag_register_event_callback(int (*callback
)(enum jtag_event event
, void *priv
), void *priv
)
213 jtag_event_callback_t
**callbacks_p
= &jtag_event_callbacks
;
215 if (callback
== NULL
)
217 return ERROR_INVALID_ARGUMENTS
;
222 while ((*callbacks_p
)->next
)
223 callbacks_p
= &((*callbacks_p
)->next
);
224 callbacks_p
= &((*callbacks_p
)->next
);
227 (*callbacks_p
) = malloc(sizeof(jtag_event_callback_t
));
228 (*callbacks_p
)->callback
= callback
;
229 (*callbacks_p
)->priv
= priv
;
230 (*callbacks_p
)->next
= NULL
;
235 int jtag_unregister_event_callback(int (*callback
)(enum jtag_event event
, void *priv
))
237 jtag_event_callback_t
**callbacks_p
= &jtag_event_callbacks
;
239 if (callback
== NULL
)
241 return ERROR_INVALID_ARGUMENTS
;
246 jtag_event_callback_t
**next
= &((*callbacks_p
)->next
);
247 if ((*callbacks_p
)->callback
== callback
)
250 *callbacks_p
= *next
;
258 int jtag_call_event_callbacks(enum jtag_event event
)
260 jtag_event_callback_t
*callback
= jtag_event_callbacks
;
262 LOG_DEBUG("jtag event: %s", jtag_event_strings
[event
]);
266 callback
->callback(event
, callback
->priv
);
267 callback
= callback
->next
;
273 static void jtag_checks(void)
275 assert(jtag_trst
== 0);
278 static void jtag_prelude(tap_state_t state
)
282 assert(state
!=TAP_INVALID
);
284 cmd_queue_cur_state
= state
;
287 void jtag_alloc_in_value32(scan_field_t
*field
)
289 interface_jtag_alloc_in_value32(field
);
292 void jtag_add_ir_scan_noverify(int in_count
, const scan_field_t
*in_fields
,
297 int retval
= interface_jtag_add_ir_scan(in_count
, in_fields
, state
);
298 jtag_set_error(retval
);
302 void jtag_add_ir_scan(int in_num_fields
, scan_field_t
*in_fields
, tap_state_t state
)
304 if (jtag_verify
&&jtag_verify_capture_ir
)
306 /* 8 x 32 bit id's is enough for all invocations */
308 for (int j
= 0; j
< in_num_fields
; j
++)
310 /* if we are to run a verification of the ir scan, we need to get the input back.
311 * We may have to allocate space if the caller didn't ask for the input back.
313 in_fields
[j
].check_value
=in_fields
[j
].tap
->expected
;
314 in_fields
[j
].check_mask
=in_fields
[j
].tap
->expected_mask
;
316 jtag_add_scan_check(jtag_add_ir_scan_noverify
, in_num_fields
, in_fields
, state
);
319 jtag_add_ir_scan_noverify(in_num_fields
, in_fields
, state
);
323 void jtag_add_plain_ir_scan(int in_num_fields
, const scan_field_t
*in_fields
,
328 int retval
= interface_jtag_add_plain_ir_scan(
329 in_num_fields
, in_fields
, state
);
330 jtag_set_error(retval
);
333 void jtag_add_callback(jtag_callback1_t f
, u8
*in
)
335 interface_jtag_add_callback(f
, in
);
338 void jtag_add_callback4(jtag_callback_t f
, u8
*in
,
339 jtag_callback_data_t data1
, jtag_callback_data_t data2
,
340 jtag_callback_data_t data3
)
342 interface_jtag_add_callback4(f
, in
, data1
, data2
, data3
);
345 int jtag_check_value_inner(u8
*captured
, u8
*in_check_value
, u8
*in_check_mask
, int num_bits
);
347 static int jtag_check_value_mask_callback(u8
*in
, jtag_callback_data_t data1
, jtag_callback_data_t data2
, jtag_callback_data_t data3
)
349 return jtag_check_value_inner(in
, (u8
*)data1
, (u8
*)data2
, (int)data3
);
352 static void jtag_add_scan_check(void (*jtag_add_scan
)(int in_num_fields
, const scan_field_t
*in_fields
, tap_state_t state
),
353 int in_num_fields
, scan_field_t
*in_fields
, tap_state_t state
)
355 for (int i
= 0; i
< in_num_fields
; i
++)
357 struct scan_field_s
*field
= &in_fields
[i
];
358 field
->allocated
= 0;
360 if (field
->check_value
|| field
->in_value
)
362 interface_jtag_add_scan_check_alloc(field
);
366 jtag_add_scan(in_num_fields
, in_fields
, state
);
368 for (int i
= 0; i
< in_num_fields
; i
++)
370 if ((in_fields
[i
].check_value
!= NULL
) && (in_fields
[i
].in_value
!= NULL
))
372 /* this is synchronous for a minidriver */
373 jtag_add_callback4(jtag_check_value_mask_callback
, in_fields
[i
].in_value
,
374 (jtag_callback_data_t
)in_fields
[i
].check_value
,
375 (jtag_callback_data_t
)in_fields
[i
].check_mask
,
376 (jtag_callback_data_t
)in_fields
[i
].num_bits
);
378 if (in_fields
[i
].allocated
)
380 free(in_fields
[i
].in_value
);
382 if (in_fields
[i
].modified
)
384 in_fields
[i
].in_value
= NULL
;
389 void jtag_add_dr_scan_check(int in_num_fields
, scan_field_t
*in_fields
, tap_state_t state
)
393 jtag_add_scan_check(jtag_add_dr_scan
, in_num_fields
, in_fields
, state
);
396 jtag_add_dr_scan(in_num_fields
, in_fields
, state
);
401 void jtag_add_dr_scan(int in_num_fields
, const scan_field_t
*in_fields
,
407 retval
= interface_jtag_add_dr_scan(in_num_fields
, in_fields
, state
);
408 jtag_set_error(retval
);
411 void jtag_add_plain_dr_scan(int in_num_fields
, const scan_field_t
*in_fields
,
417 retval
= interface_jtag_add_plain_dr_scan(in_num_fields
, in_fields
, state
);
418 jtag_set_error(retval
);
421 void jtag_add_dr_out(jtag_tap_t
* tap
,
422 int num_fields
, const int* num_bits
, const u32
* value
,
423 tap_state_t end_state
)
425 assert(end_state
!= TAP_INVALID
);
427 cmd_queue_cur_state
= end_state
;
429 interface_jtag_add_dr_out(tap
,
430 num_fields
, num_bits
, value
,
434 void jtag_add_tlr(void)
436 jtag_prelude(TAP_RESET
);
437 jtag_set_error(interface_jtag_add_tlr());
438 jtag_call_event_callbacks(JTAG_TRST_ASSERTED
);
441 void jtag_add_pathmove(int num_states
, const tap_state_t
*path
)
443 tap_state_t cur_state
= cmd_queue_cur_state
;
445 /* the last state has to be a stable state */
446 if (!tap_is_state_stable(path
[num_states
- 1]))
448 LOG_ERROR("BUG: TAP path doesn't finish in a stable state");
449 jtag_set_error(ERROR_JTAG_NOT_STABLE_STATE
);
453 for (int i
= 0; i
< num_states
; i
++)
455 if (path
[i
] == TAP_RESET
)
457 LOG_ERROR("BUG: TAP_RESET is not a valid state for pathmove sequences");
458 jtag_set_error(ERROR_JTAG_STATE_INVALID
);
462 if ( tap_state_transition(cur_state
, true) != path
[i
]
463 && tap_state_transition(cur_state
, false) != path
[i
])
465 LOG_ERROR("BUG: %s -> %s isn't a valid TAP transition",
466 tap_state_name(cur_state
), tap_state_name(path
[i
]));
467 jtag_set_error(ERROR_JTAG_TRANSITION_INVALID
);
475 jtag_set_error(interface_jtag_add_pathmove(num_states
, path
));
476 cmd_queue_cur_state
= path
[num_states
- 1];
479 void jtag_add_runtest(int num_cycles
, tap_state_t state
)
482 jtag_set_error(interface_jtag_add_runtest(num_cycles
, state
));
486 void jtag_add_clocks(int num_cycles
)
488 if (!tap_is_state_stable(cmd_queue_cur_state
))
490 LOG_ERROR("jtag_add_clocks() called with TAP in unstable state \"%s\"",
491 tap_state_name(cmd_queue_cur_state
));
492 jtag_set_error(ERROR_JTAG_NOT_STABLE_STATE
);
499 jtag_set_error(interface_jtag_add_clocks(num_cycles
));
503 void jtag_add_reset(int req_tlr_or_trst
, int req_srst
)
505 int trst_with_tlr
= 0;
507 /* FIX!!! there are *many* different cases here. A better
508 * approach is needed for legal combinations of transitions...
510 if ((jtag_reset_config
& RESET_HAS_SRST
)&&
511 (jtag_reset_config
& RESET_HAS_TRST
)&&
512 ((jtag_reset_config
& RESET_SRST_PULLS_TRST
)==0))
514 if (((req_tlr_or_trst
&&!jtag_trst
)||
515 (!req_tlr_or_trst
&&jtag_trst
))&&
516 ((req_srst
&&!jtag_srst
)||
517 (!req_srst
&&jtag_srst
)))
519 /* FIX!!! srst_pulls_trst allows 1,1 => 0,0 transition.... */
520 //LOG_ERROR("BUG: transition of req_tlr_or_trst and req_srst in the same jtag_add_reset() call is undefined");
524 /* Make sure that jtag_reset_config allows the requested reset */
525 /* if SRST pulls TRST, we can't fulfill srst == 1 with trst == 0 */
526 if (((jtag_reset_config
& RESET_SRST_PULLS_TRST
) && (req_srst
== 1)) && (!req_tlr_or_trst
))
528 LOG_ERROR("BUG: requested reset would assert trst");
529 jtag_set_error(ERROR_FAIL
);
533 /* if TRST pulls SRST, we reset with TAP T-L-R */
534 if (((jtag_reset_config
& RESET_TRST_PULLS_SRST
) && (req_tlr_or_trst
)) && (req_srst
== 0))
539 if (req_srst
&& !(jtag_reset_config
& RESET_HAS_SRST
))
541 LOG_ERROR("BUG: requested SRST assertion, but the current configuration doesn't support this");
542 jtag_set_error(ERROR_FAIL
);
548 if (!trst_with_tlr
&& (jtag_reset_config
& RESET_HAS_TRST
))
560 jtag_srst
= req_srst
;
562 int retval
= interface_jtag_add_reset(jtag_trst
, jtag_srst
);
563 if (retval
!= ERROR_OK
)
565 jtag_set_error(retval
);
568 jtag_execute_queue();
572 LOG_DEBUG("SRST line asserted");
576 LOG_DEBUG("SRST line released");
577 if (jtag_nsrst_delay
)
578 jtag_add_sleep(jtag_nsrst_delay
* 1000);
583 LOG_DEBUG("JTAG reset with RESET instead of TRST");
584 jtag_set_end_state(TAP_RESET
);
591 /* we just asserted nTRST, so we're now in Test-Logic-Reset,
592 * and inform possible listeners about this
594 LOG_DEBUG("TRST line asserted");
595 tap_set_state(TAP_RESET
);
596 jtag_call_event_callbacks(JTAG_TRST_ASSERTED
);
600 if (jtag_ntrst_delay
)
601 jtag_add_sleep(jtag_ntrst_delay
* 1000);
605 tap_state_t
jtag_set_end_state(tap_state_t state
)
607 if ((state
== TAP_DRSHIFT
)||(state
== TAP_IRSHIFT
))
609 LOG_ERROR("BUG: TAP_DRSHIFT/IRSHIFT can't be end state. Calling code should use a larger scan field");
612 if (state
!=TAP_INVALID
)
613 cmd_queue_end_state
= state
;
614 return cmd_queue_end_state
;
617 tap_state_t
jtag_get_end_state(void)
619 return cmd_queue_end_state
;
622 void jtag_add_sleep(u32 us
)
624 /// @todo Here, keep_alive() appears to be a layering violation!!!
626 jtag_set_error(interface_jtag_add_sleep(us
));
629 int jtag_check_value_inner(u8
*captured
, u8
*in_check_value
, u8
*in_check_mask
, int num_bits
)
631 int retval
= ERROR_OK
;
633 int compare_failed
= 0;
636 compare_failed
= buf_cmp_mask(captured
, in_check_value
, in_check_mask
, num_bits
);
638 compare_failed
= buf_cmp(captured
, in_check_value
, num_bits
);
641 /* An error handler could have caught the failing check
642 * only report a problem when there wasn't a handler, or if the handler
643 * acknowledged the error
646 LOG_WARNING("TAP %s:",
647 jtag_tap_name(field->tap));
651 char *captured_char
= buf_to_str(captured
, (num_bits
> DEBUG_JTAG_IOZ
) ? DEBUG_JTAG_IOZ
: num_bits
, 16);
652 char *in_check_value_char
= buf_to_str(in_check_value
, (num_bits
> DEBUG_JTAG_IOZ
) ? DEBUG_JTAG_IOZ
: num_bits
, 16);
656 char *in_check_mask_char
;
657 in_check_mask_char
= buf_to_str(in_check_mask
, (num_bits
> DEBUG_JTAG_IOZ
) ? DEBUG_JTAG_IOZ
: num_bits
, 16);
658 LOG_WARNING("value captured during scan didn't pass the requested check:");
659 LOG_WARNING("captured: 0x%s check_value: 0x%s check_mask: 0x%s",
660 captured_char
, in_check_value_char
, in_check_mask_char
);
661 free(in_check_mask_char
);
665 LOG_WARNING("value captured during scan didn't pass the requested check: captured: 0x%s check_value: 0x%s", captured_char
, in_check_value_char
);
669 free(in_check_value_char
);
671 retval
= ERROR_JTAG_QUEUE_FAILED
;
678 void jtag_check_value_mask(scan_field_t
*field
, u8
*value
, u8
*mask
)
680 assert(field
->in_value
!= NULL
);
684 /* no checking to do */
688 jtag_execute_queue_noclear();
690 int retval
=jtag_check_value_inner(field
->in_value
, value
, mask
, field
->num_bits
);
691 jtag_set_error(retval
);
696 int default_interface_jtag_execute_queue(void)
700 LOG_ERROR("No JTAG interface configured yet. "
701 "Issue 'init' command in startup scripts "
702 "before communicating with targets.");
706 return jtag
->execute_queue();
709 void jtag_execute_queue_noclear(void)
711 jtag_flush_queue_count
++;
712 jtag_set_error(interface_jtag_execute_queue());
715 int jtag_get_flush_queue_count(void)
717 return jtag_flush_queue_count
;
720 int jtag_execute_queue(void)
722 jtag_execute_queue_noclear();
723 return jtag_error_clear();
726 static int jtag_reset_callback(enum jtag_event event
, void *priv
)
728 jtag_tap_t
*tap
= priv
;
732 if (event
== JTAG_TRST_ASSERTED
)
734 buf_set_ones(tap
->cur_instr
, tap
->ir_length
);
741 void jtag_sleep(u32 us
)
743 alive_sleep(us
/1000);
746 /// maximum number of JTAG devices expected in the chain
747 #define JTAG_MAX_CHAIN_SIZE 20
749 #define EXTRACT_MFG(X) (((X) & 0xffe) >> 1)
750 #define EXTRACT_PART(X) (((X) & 0xffff000) >> 12)
751 #define EXTRACT_VER(X) (((X) & 0xf0000000) >> 28)
753 static int jtag_examine_chain_execute(u8
*idcode_buffer
, unsigned num_idcode
)
755 scan_field_t field
= {
757 .num_bits
= num_idcode
* 32,
758 .out_value
= idcode_buffer
,
759 .in_value
= idcode_buffer
,
762 // initialize to the end of chain ID value
763 for (unsigned i
= 0; i
< JTAG_MAX_CHAIN_SIZE
; i
++)
764 buf_set_u32(idcode_buffer
, i
* 32, 32, 0x000000FF);
766 jtag_add_plain_dr_scan(1, &field
, TAP_RESET
);
767 return jtag_execute_queue();
770 static bool jtag_examine_chain_check(u8
*idcodes
, unsigned count
)
775 for (unsigned i
= 0; i
< count
* 4; i
++)
777 zero_check
|= idcodes
[i
];
778 one_check
&= idcodes
[i
];
781 /* if there wasn't a single non-zero bit or if all bits were one,
782 * the scan is not valid */
783 if (zero_check
== 0x00 || one_check
== 0xff)
785 LOG_ERROR("JTAG communication failure: check connection, "
786 "JTAG interface, target power etc.");
792 static void jtag_examine_chain_display(enum log_levels level
, const char *msg
,
793 const char *name
, u32 idcode
)
795 log_printf_lf(level
, __FILE__
, __LINE__
, __FUNCTION__
,
796 "JTAG tap: %s %16.16s: 0x%08x "
797 "(mfg: 0x%3.3x, part: 0x%4.4x, ver: 0x%1.1x)",
799 EXTRACT_MFG(idcode
), EXTRACT_PART(idcode
), EXTRACT_VER(idcode
) );
802 static bool jtag_idcode_is_final(u32 idcode
)
804 return idcode
== 0x000000FF || idcode
== 0xFFFFFFFF;
808 * This helper checks that remaining bits in the examined chain data are
809 * all as expected, but a single JTAG device requires only 64 bits to be
810 * read back correctly. This can help identify and diagnose problems
811 * with the JTAG chain earlier, gives more helpful/explicit error messages.
813 static void jtag_examine_chain_end(u8
*idcodes
, unsigned count
, unsigned max
)
815 bool triggered
= false;
816 for ( ; count
< max
- 31; count
+= 32)
818 u32 idcode
= buf_get_u32(idcodes
, count
, 32);
819 // do not trigger the warning if the data looks good
820 if (!triggered
&& jtag_idcode_is_final(idcode
))
822 LOG_WARNING("Unexpected idcode after end of chain: %d 0x%08x",
828 static bool jtag_examine_chain_match_tap(const struct jtag_tap_s
*tap
)
830 if (0 == tap
->expected_ids_cnt
)
832 /// @todo Enable LOG_INFO to ask for reports about unknown TAP IDs.
834 LOG_INFO("Uknown JTAG TAP ID: 0x%08x", tap
->idcode
)
835 LOG_INFO("Please report the chip name and reported ID code to the openocd project");
840 /* Loop over the expected identification codes and test for a match */
842 for (ii
= 0; ii
< tap
->expected_ids_cnt
; ii
++)
844 if (tap
->idcode
== tap
->expected_ids
[ii
])
848 /* If none of the expected ids matched, log an error */
849 if (ii
!= tap
->expected_ids_cnt
)
851 LOG_INFO("JTAG Tap/device matched");
854 jtag_examine_chain_display(LOG_LVL_ERROR
, "got",
855 tap
->dotted_name
, tap
->idcode
);
856 for (ii
= 0; ii
< tap
->expected_ids_cnt
; ii
++)
859 snprintf(msg
, sizeof(msg
), "expected %hhu of %hhu",
860 ii
+ 1, tap
->expected_ids_cnt
);
861 jtag_examine_chain_display(LOG_LVL_ERROR
, msg
,
862 tap
->dotted_name
, tap
->expected_ids
[ii
]);
867 /* Try to examine chain layout according to IEEE 1149.1 §12
869 int jtag_examine_chain(void)
871 u8 idcode_buffer
[JTAG_MAX_CHAIN_SIZE
* 4];
872 unsigned device_count
= 0;
874 jtag_examine_chain_execute(idcode_buffer
, JTAG_MAX_CHAIN_SIZE
);
876 if (!jtag_examine_chain_check(idcode_buffer
, JTAG_MAX_CHAIN_SIZE
))
877 return ERROR_JTAG_INIT_FAILED
;
879 /* point at the 1st tap */
880 jtag_tap_t
*tap
= jtag_tap_next_enabled(NULL
);
883 LOG_ERROR("JTAG: No taps enabled?");
884 return ERROR_JTAG_INIT_FAILED
;
887 for (unsigned bit_count
= 0; bit_count
< (JTAG_MAX_CHAIN_SIZE
* 32) - 31;)
889 u32 idcode
= buf_get_u32(idcode_buffer
, bit_count
, 32);
890 if ((idcode
& 1) == 0)
892 /* LSB must not be 0, this indicates a device in bypass */
893 LOG_WARNING("Tap/Device does not have IDCODE");
901 * End of chain (invalid manufacturer ID) some devices, such
902 * as AVR will output all 1's instead of TDI input value at
905 if (jtag_idcode_is_final(idcode
))
907 jtag_examine_chain_end(idcode_buffer
,
908 bit_count
+ 32, JTAG_MAX_CHAIN_SIZE
* 32);
912 jtag_examine_chain_display(LOG_LVL_INFO
, "tap/device found",
913 tap
? tap
->dotted_name
: "(not-named)",
922 tap
->idcode
= idcode
;
924 // ensure the TAP ID does matches what was expected
925 if (!jtag_examine_chain_match_tap(tap
))
926 return ERROR_JTAG_INIT_FAILED
;
928 tap
= jtag_tap_next_enabled(tap
);
931 /* see if number of discovered devices matches configuration */
932 if (device_count
!= jtag_tap_count_enabled())
934 LOG_ERROR("number of discovered devices in JTAG chain (%i) "
935 "does not match (enabled) configuration (%i), total taps: %d",
936 device_count
, jtag_tap_count_enabled(), jtag_tap_count());
937 LOG_ERROR("check the config file and ensure proper JTAG communication"
938 " (connections, speed, ...)");
939 return ERROR_JTAG_INIT_FAILED
;
945 int jtag_validate_chain(void)
948 int total_ir_length
= 0;
956 tap
= jtag_tap_next_enabled(tap
);
960 total_ir_length
+= tap
->ir_length
;
963 total_ir_length
+= 2;
964 ir_test
= malloc(CEIL(total_ir_length
, 8));
965 buf_set_ones(ir_test
, total_ir_length
);
968 field
.num_bits
= total_ir_length
;
969 field
.out_value
= ir_test
;
970 field
.in_value
= ir_test
;
973 jtag_add_plain_ir_scan(1, &field
, TAP_RESET
);
974 jtag_execute_queue();
980 tap
= jtag_tap_next_enabled(tap
);
985 val
= buf_get_u32(ir_test
, chain_pos
, 2);
988 char *cbuf
= buf_to_str(ir_test
, total_ir_length
, 16);
989 LOG_ERROR("Could not validate JTAG scan chain, IR mismatch, scan returned 0x%s. tap=%s pos=%d expected 0x1 got %0x", cbuf
, jtag_tap_name(tap
), chain_pos
, val
);
992 return ERROR_JTAG_INIT_FAILED
;
994 chain_pos
+= tap
->ir_length
;
997 val
= buf_get_u32(ir_test
, chain_pos
, 2);
1000 char *cbuf
= buf_to_str(ir_test
, total_ir_length
, 16);
1001 LOG_ERROR("Could not validate end of JTAG scan chain, IR mismatch, scan returned 0x%s. pos=%d expected 0x3 got %0x", cbuf
, chain_pos
, val
);
1004 return ERROR_JTAG_INIT_FAILED
;
1013 void jtag_tap_init(jtag_tap_t
*tap
)
1015 assert(0 != tap
->ir_length
);
1017 tap
->expected
= malloc(tap
->ir_length
);
1018 tap
->expected_mask
= malloc(tap
->ir_length
);
1019 tap
->cur_instr
= malloc(tap
->ir_length
);
1021 buf_set_u32(tap
->expected
, 0, tap
->ir_length
, tap
->ir_capture_value
);
1022 buf_set_u32(tap
->expected_mask
, 0, tap
->ir_length
, tap
->ir_capture_mask
);
1023 buf_set_ones(tap
->cur_instr
, tap
->ir_length
);
1025 // place TAP in bypass mode
1027 // register the reset callback for the TAP
1028 jtag_register_event_callback(&jtag_reset_callback
, tap
);
1030 LOG_DEBUG("Created Tap: %s @ abs position %d, "
1031 "irlen %d, capture: 0x%x mask: 0x%x", tap
->dotted_name
,
1032 tap
->abs_chain_position
, tap
->ir_length
,
1033 tap
->ir_capture_value
, tap
->ir_capture_mask
);
1037 void jtag_tap_free(jtag_tap_t
*tap
)
1039 /// @todo is anything missing? no memory leaks please
1040 free((void *)tap
->expected_ids
);
1041 free((void *)tap
->chip
);
1042 free((void *)tap
->tapname
);
1043 free((void *)tap
->dotted_name
);
1047 int jtag_interface_init(struct command_context_s
*cmd_ctx
)
1052 if (!jtag_interface
)
1054 /* nothing was previously specified by "interface" command */
1055 LOG_ERROR("JTAG interface has to be specified, see \"interface\" command");
1056 return ERROR_JTAG_INVALID_INTERFACE
;
1060 jtag_interface
->khz(jtag_get_speed_khz(), &jtag_speed
);
1064 if (jtag_interface
->init() != ERROR_OK
)
1065 return ERROR_JTAG_INIT_FAILED
;
1067 jtag
= jtag_interface
;
1071 static int jtag_init_inner(struct command_context_s
*cmd_ctx
)
1076 LOG_DEBUG("Init JTAG chain");
1078 tap
= jtag_tap_next_enabled(NULL
);
1080 LOG_ERROR("There are no enabled taps?");
1081 return ERROR_JTAG_INIT_FAILED
;
1085 if ((retval
=jtag_execute_queue())!=ERROR_OK
)
1088 /* examine chain first, as this could discover the real chain layout */
1089 if (jtag_examine_chain() != ERROR_OK
)
1091 LOG_ERROR("trying to validate configured JTAG chain anyway...");
1094 if (jtag_validate_chain() != ERROR_OK
)
1096 LOG_WARNING("Could not validate JTAG chain, continuing anyway...");
1102 int jtag_interface_quit(void)
1104 if (!jtag
|| !jtag
->quit
)
1107 // close the JTAG interface
1108 int result
= jtag
->quit();
1109 if (ERROR_OK
!= result
)
1110 LOG_ERROR("failed: %d", result
);
1116 int jtag_init_reset(struct command_context_s
*cmd_ctx
)
1120 if ((retval
=jtag_interface_init(cmd_ctx
)) != ERROR_OK
)
1123 LOG_DEBUG("Trying to bring the JTAG controller to life by asserting TRST / RESET");
1125 /* Reset can happen after a power cycle.
1127 * Ideally we would only assert TRST or run RESET before the target reset.
1129 * However w/srst_pulls_trst, trst is asserted together with the target
1130 * reset whether we want it or not.
1132 * NB! Some targets have JTAG circuitry disabled until a
1133 * trst & srst has been asserted.
1135 * NB! here we assume nsrst/ntrst delay are sufficient!
1137 * NB! order matters!!!! srst *can* disconnect JTAG circuitry
1140 jtag_add_reset(1, 0); /* RESET or TRST */
1141 if (jtag_reset_config
& RESET_HAS_SRST
)
1143 jtag_add_reset(1, 1);
1144 if ((jtag_reset_config
& RESET_SRST_PULLS_TRST
)==0)
1145 jtag_add_reset(0, 1);
1147 jtag_add_reset(0, 0);
1148 if ((retval
= jtag_execute_queue()) != ERROR_OK
)
1151 /* Check that we can communication on the JTAG chain + eventually we want to
1152 * be able to perform enumeration only after OpenOCD has started
1153 * telnet and GDB server
1155 * That would allow users to more easily perform any magic they need to before
1158 return jtag_init_inner(cmd_ctx
);
1161 int jtag_init(struct command_context_s
*cmd_ctx
)
1164 if ((retval
=jtag_interface_init(cmd_ctx
)) != ERROR_OK
)
1166 if (jtag_init_inner(cmd_ctx
)==ERROR_OK
)
1170 return jtag_init_reset(cmd_ctx
);
1173 void jtag_set_speed_khz(unsigned khz
)
1177 unsigned jtag_get_speed_khz(void)
1181 int jtag_get_speed(void)
1186 int jtag_set_speed(int speed
)
1189 /* this command can be called during CONFIG,
1190 * in which case jtag isn't initialized */
1192 return jtag
? jtag
->speed(speed
) : ERROR_OK
;
1195 void jtag_set_verify(bool enable
)
1197 jtag_verify
= enable
;
1200 bool jtag_will_verify()
1205 void jtag_set_verify_capture_ir(bool enable
)
1207 jtag_verify_capture_ir
= enable
;
1210 bool jtag_will_verify_capture_ir()
1212 return jtag_verify_capture_ir
;
1215 int jtag_power_dropout(int *dropout
)
1217 return jtag
->power_dropout(dropout
);
1220 int jtag_srst_asserted(int *srst_asserted
)
1222 return jtag
->srst_asserted(srst_asserted
);
1225 void jtag_tap_handle_event( jtag_tap_t
* tap
, enum jtag_tap_event e
)
1227 jtag_tap_event_action_t
* jteap
;
1230 jteap
= tap
->event_action
;
1234 if (jteap
->event
== e
) {
1236 LOG_DEBUG( "JTAG tap: %s event: %d (%s) action: %s\n",
1239 Jim_Nvp_value2name_simple(nvp_jtag_tap_event
, e
)->name
,
1240 Jim_GetString(jteap
->body
, NULL
) );
1241 if (Jim_EvalObj(interp
, jteap
->body
) != JIM_OK
) {
1242 Jim_PrintErrorMessage(interp
);
1246 jteap
= jteap
->next
;
1250 LOG_DEBUG( "event %d %s - no action",
1252 Jim_Nvp_value2name_simple( nvp_jtag_tap_event
, e
)->name
);
1256 int jtag_add_statemove(tap_state_t goal_state
)
1258 tap_state_t cur_state
= cmd_queue_cur_state
;
1260 LOG_DEBUG( "cur_state=%s goal_state=%s",
1261 tap_state_name(cur_state
),
1262 tap_state_name(goal_state
) );
1265 if (goal_state
==cur_state
)
1266 ; /* nothing to do */
1267 else if( goal_state
==TAP_RESET
)
1271 else if( tap_is_state_stable(cur_state
) && tap_is_state_stable(goal_state
) )
1273 unsigned tms_bits
= tap_get_tms_path(cur_state
, goal_state
);
1274 unsigned tms_count
= tap_get_tms_path_len(cur_state
, goal_state
);
1275 tap_state_t moves
[8];
1276 assert(tms_count
< DIM(moves
));
1278 for (unsigned i
= 0; i
< tms_count
; i
++, tms_bits
>>= 1)
1280 bool bit
= tms_bits
& 1;
1282 cur_state
= tap_state_transition(cur_state
, bit
);
1283 moves
[i
] = cur_state
;
1286 jtag_add_pathmove(tms_count
, moves
);
1288 else if( tap_state_transition(cur_state
, true) == goal_state
1289 || tap_state_transition(cur_state
, false) == goal_state
)
1291 jtag_add_pathmove(1, &goal_state
);
1300 enum reset_types
jtag_get_reset_config(void)
1302 return jtag_reset_config
;
1304 void jtag_set_reset_config(enum reset_types type
)
1306 jtag_reset_config
= type
;
1309 int jtag_get_trst(void)
1313 int jtag_get_srst(void)
1318 void jtag_set_nsrst_delay(unsigned delay
)
1320 jtag_nsrst_delay
= delay
;
1322 unsigned jtag_get_nsrst_delay(void)
1324 return jtag_nsrst_delay
;
1326 void jtag_set_ntrst_delay(unsigned delay
)
1328 jtag_ntrst_delay
= delay
;
1330 unsigned jtag_get_ntrst_delay(void)
1332 return jtag_ntrst_delay
;
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)