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 static int jtag_trst
= 0;
67 static int jtag_srst
= 0;
70 * List all TAPs that have been created.
72 static jtag_tap_t
*__jtag_all_taps
= NULL
;
74 * The number of TAPs in the __jtag_all_taps list, used to track the
75 * assigned chain position to new TAPs
77 static unsigned jtag_num_taps
= 0;
79 static enum reset_types jtag_reset_config
= RESET_NONE
;
80 static tap_state_t cmd_queue_end_state
= TAP_RESET
;
81 tap_state_t cmd_queue_cur_state
= TAP_RESET
;
83 static bool jtag_verify_capture_ir
= true;
84 static int jtag_verify
= 1;
86 /* how long the OpenOCD should wait before attempting JTAG communication after reset lines deasserted (in ms) */
87 static int jtag_nsrst_delay
= 0; /* default to no nSRST delay */
88 static int jtag_ntrst_delay
= 0; /* default to no nTRST delay */
90 /* callbacks to inform high-level handlers about JTAG state changes */
91 static jtag_event_callback_t
*jtag_event_callbacks
;
94 static int speed_khz
= 0;
95 /* flag if the kHz speed was defined */
96 static bool hasKHz
= false;
97 static int jtag_speed
= 0;
99 struct jtag_interface_s
*jtag
= NULL
;
102 jtag_interface_t
*jtag_interface
= NULL
;
104 void jtag_set_error(int error
)
106 if ((error
== ERROR_OK
) || (jtag_error
!= ERROR_OK
))
110 int jtag_get_error(void)
114 int jtag_error_clear(void)
116 int temp
= jtag_error
;
117 jtag_error
= ERROR_OK
;
122 jtag_tap_t
*jtag_all_taps(void)
124 return __jtag_all_taps
;
127 unsigned jtag_tap_count(void)
129 return jtag_num_taps
;
132 unsigned jtag_tap_count_enabled(void)
134 jtag_tap_t
*t
= jtag_all_taps();
145 /// Append a new TAP to the chain of all taps.
146 void jtag_tap_add(struct jtag_tap_s
*t
)
148 t
->abs_chain_position
= jtag_num_taps
++;
150 jtag_tap_t
**tap
= &__jtag_all_taps
;
152 tap
= &(*tap
)->next_tap
;
156 jtag_tap_t
*jtag_tap_by_string(const char *s
)
158 /* try by name first */
159 jtag_tap_t
*t
= jtag_all_taps();
162 if (0 == strcmp(t
->dotted_name
, s
))
167 /* no tap found by name, so try to parse the name as a number */
169 unsigned n
= strtoul(s
, &cp
, 0);
170 if ((s
== cp
) || (*cp
!= 0))
173 return jtag_tap_by_position(n
);
176 jtag_tap_t
*jtag_tap_by_jim_obj(Jim_Interp
*interp
, Jim_Obj
*o
)
178 const char *cp
= Jim_GetString(o
, NULL
);
179 jtag_tap_t
*t
= cp
? jtag_tap_by_string(cp
) : NULL
;
183 Jim_SetResult_sprintf(interp
, "Tap '%s' could not be found", cp
);
187 /* returns a pointer to the n-th device in the scan chain */
188 jtag_tap_t
*jtag_tap_by_position(unsigned n
)
190 jtag_tap_t
*t
= jtag_all_taps();
198 const char *jtag_tap_name(const jtag_tap_t
*tap
)
200 return (tap
== NULL
) ? "(unknown)" : tap
->dotted_name
;
204 int jtag_register_event_callback(int (*callback
)(enum jtag_event event
, void *priv
), void *priv
)
206 jtag_event_callback_t
**callbacks_p
= &jtag_event_callbacks
;
208 if (callback
== NULL
)
210 return ERROR_INVALID_ARGUMENTS
;
215 while ((*callbacks_p
)->next
)
216 callbacks_p
= &((*callbacks_p
)->next
);
217 callbacks_p
= &((*callbacks_p
)->next
);
220 (*callbacks_p
) = malloc(sizeof(jtag_event_callback_t
));
221 (*callbacks_p
)->callback
= callback
;
222 (*callbacks_p
)->priv
= priv
;
223 (*callbacks_p
)->next
= NULL
;
228 int jtag_unregister_event_callback(int (*callback
)(enum jtag_event event
, void *priv
))
230 jtag_event_callback_t
**callbacks_p
= &jtag_event_callbacks
;
232 if (callback
== NULL
)
234 return ERROR_INVALID_ARGUMENTS
;
239 jtag_event_callback_t
**next
= &((*callbacks_p
)->next
);
240 if ((*callbacks_p
)->callback
== callback
)
243 *callbacks_p
= *next
;
251 int jtag_call_event_callbacks(enum jtag_event event
)
253 jtag_event_callback_t
*callback
= jtag_event_callbacks
;
255 LOG_DEBUG("jtag event: %s", jtag_event_strings
[event
]);
259 callback
->callback(event
, callback
->priv
);
260 callback
= callback
->next
;
266 static void jtag_checks(void)
268 assert(jtag_trst
== 0);
271 static void jtag_prelude(tap_state_t state
)
275 assert(state
!=TAP_INVALID
);
277 cmd_queue_cur_state
= state
;
280 void jtag_alloc_in_value32(scan_field_t
*field
)
282 interface_jtag_alloc_in_value32(field
);
285 void jtag_add_ir_scan_noverify(int in_count
, const scan_field_t
*in_fields
,
290 int retval
= interface_jtag_add_ir_scan(in_count
, in_fields
, state
);
291 jtag_set_error(retval
);
295 void jtag_add_ir_scan(int in_num_fields
, scan_field_t
*in_fields
, tap_state_t state
)
297 if (jtag_verify
&&jtag_verify_capture_ir
)
299 /* 8 x 32 bit id's is enough for all invocations */
301 for (int j
= 0; j
< in_num_fields
; j
++)
303 /* if we are to run a verification of the ir scan, we need to get the input back.
304 * We may have to allocate space if the caller didn't ask for the input back.
306 in_fields
[j
].check_value
=in_fields
[j
].tap
->expected
;
307 in_fields
[j
].check_mask
=in_fields
[j
].tap
->expected_mask
;
309 jtag_add_scan_check(jtag_add_ir_scan_noverify
, in_num_fields
, in_fields
, state
);
312 jtag_add_ir_scan_noverify(in_num_fields
, in_fields
, state
);
316 void jtag_add_plain_ir_scan(int in_num_fields
, const scan_field_t
*in_fields
,
321 int retval
= interface_jtag_add_plain_ir_scan(
322 in_num_fields
, in_fields
, state
);
323 jtag_set_error(retval
);
326 void jtag_add_callback(jtag_callback1_t f
, u8
*in
)
328 interface_jtag_add_callback(f
, in
);
331 void jtag_add_callback4(jtag_callback_t f
, u8
*in
,
332 jtag_callback_data_t data1
, jtag_callback_data_t data2
,
333 jtag_callback_data_t data3
)
335 interface_jtag_add_callback4(f
, in
, data1
, data2
, data3
);
338 int jtag_check_value_inner(u8
*captured
, u8
*in_check_value
, u8
*in_check_mask
, int num_bits
);
340 static int jtag_check_value_mask_callback(u8
*in
, jtag_callback_data_t data1
, jtag_callback_data_t data2
, jtag_callback_data_t data3
)
342 return jtag_check_value_inner(in
, (u8
*)data1
, (u8
*)data2
, (int)data3
);
345 static void jtag_add_scan_check(void (*jtag_add_scan
)(int in_num_fields
, const scan_field_t
*in_fields
, tap_state_t state
),
346 int in_num_fields
, scan_field_t
*in_fields
, tap_state_t state
)
348 for (int i
= 0; i
< in_num_fields
; i
++)
350 struct scan_field_s
*field
= &in_fields
[i
];
351 field
->allocated
= 0;
353 if (field
->check_value
|| field
->in_value
)
355 interface_jtag_add_scan_check_alloc(field
);
359 jtag_add_scan(in_num_fields
, in_fields
, state
);
361 for (int i
= 0; i
< in_num_fields
; i
++)
363 if ((in_fields
[i
].check_value
!= NULL
) && (in_fields
[i
].in_value
!= NULL
))
365 /* this is synchronous for a minidriver */
366 jtag_add_callback4(jtag_check_value_mask_callback
, in_fields
[i
].in_value
,
367 (jtag_callback_data_t
)in_fields
[i
].check_value
,
368 (jtag_callback_data_t
)in_fields
[i
].check_mask
,
369 (jtag_callback_data_t
)in_fields
[i
].num_bits
);
371 if (in_fields
[i
].allocated
)
373 free(in_fields
[i
].in_value
);
375 if (in_fields
[i
].modified
)
377 in_fields
[i
].in_value
= NULL
;
382 void jtag_add_dr_scan_check(int in_num_fields
, scan_field_t
*in_fields
, tap_state_t state
)
386 jtag_add_scan_check(jtag_add_dr_scan
, in_num_fields
, in_fields
, state
);
389 jtag_add_dr_scan(in_num_fields
, in_fields
, state
);
394 void jtag_add_dr_scan(int in_num_fields
, const scan_field_t
*in_fields
,
400 retval
= interface_jtag_add_dr_scan(in_num_fields
, in_fields
, state
);
401 jtag_set_error(retval
);
404 void jtag_add_plain_dr_scan(int in_num_fields
, const scan_field_t
*in_fields
,
410 retval
= interface_jtag_add_plain_dr_scan(in_num_fields
, in_fields
, state
);
411 jtag_set_error(retval
);
414 void jtag_add_dr_out(jtag_tap_t
* tap
,
415 int num_fields
, const int* num_bits
, const u32
* value
,
416 tap_state_t end_state
)
418 assert(end_state
!= TAP_INVALID
);
420 cmd_queue_cur_state
= end_state
;
422 interface_jtag_add_dr_out(tap
,
423 num_fields
, num_bits
, value
,
427 void jtag_add_tlr(void)
429 jtag_prelude(TAP_RESET
);
430 jtag_set_error(interface_jtag_add_tlr());
431 jtag_call_event_callbacks(JTAG_TRST_ASSERTED
);
434 void jtag_add_pathmove(int num_states
, const tap_state_t
*path
)
436 tap_state_t cur_state
= cmd_queue_cur_state
;
438 /* the last state has to be a stable state */
439 if (!tap_is_state_stable(path
[num_states
- 1]))
441 LOG_ERROR("BUG: TAP path doesn't finish in a stable state");
442 jtag_set_error(ERROR_JTAG_NOT_STABLE_STATE
);
446 for (int i
= 0; i
< num_states
; i
++)
448 if (path
[i
] == TAP_RESET
)
450 LOG_ERROR("BUG: TAP_RESET is not a valid state for pathmove sequences");
451 jtag_set_error(ERROR_JTAG_STATE_INVALID
);
455 if ( tap_state_transition(cur_state
, true) != path
[i
]
456 && tap_state_transition(cur_state
, false) != path
[i
])
458 LOG_ERROR("BUG: %s -> %s isn't a valid TAP transition",
459 tap_state_name(cur_state
), tap_state_name(path
[i
]));
460 jtag_set_error(ERROR_JTAG_TRANSITION_INVALID
);
468 jtag_set_error(interface_jtag_add_pathmove(num_states
, path
));
469 cmd_queue_cur_state
= path
[num_states
- 1];
472 void jtag_add_runtest(int num_cycles
, tap_state_t state
)
475 jtag_set_error(interface_jtag_add_runtest(num_cycles
, state
));
479 void jtag_add_clocks(int num_cycles
)
481 if (!tap_is_state_stable(cmd_queue_cur_state
))
483 LOG_ERROR("jtag_add_clocks() called with TAP in unstable state \"%s\"",
484 tap_state_name(cmd_queue_cur_state
));
485 jtag_set_error(ERROR_JTAG_NOT_STABLE_STATE
);
492 jtag_set_error(interface_jtag_add_clocks(num_cycles
));
496 void jtag_add_reset(int req_tlr_or_trst
, int req_srst
)
498 int trst_with_tlr
= 0;
500 /* FIX!!! there are *many* different cases here. A better
501 * approach is needed for legal combinations of transitions...
503 if ((jtag_reset_config
& RESET_HAS_SRST
)&&
504 (jtag_reset_config
& RESET_HAS_TRST
)&&
505 ((jtag_reset_config
& RESET_SRST_PULLS_TRST
)==0))
507 if (((req_tlr_or_trst
&&!jtag_trst
)||
508 (!req_tlr_or_trst
&&jtag_trst
))&&
509 ((req_srst
&&!jtag_srst
)||
510 (!req_srst
&&jtag_srst
)))
512 /* FIX!!! srst_pulls_trst allows 1,1 => 0,0 transition.... */
513 //LOG_ERROR("BUG: transition of req_tlr_or_trst and req_srst in the same jtag_add_reset() call is undefined");
517 /* Make sure that jtag_reset_config allows the requested reset */
518 /* if SRST pulls TRST, we can't fulfill srst == 1 with trst == 0 */
519 if (((jtag_reset_config
& RESET_SRST_PULLS_TRST
) && (req_srst
== 1)) && (!req_tlr_or_trst
))
521 LOG_ERROR("BUG: requested reset would assert trst");
522 jtag_set_error(ERROR_FAIL
);
526 /* if TRST pulls SRST, we reset with TAP T-L-R */
527 if (((jtag_reset_config
& RESET_TRST_PULLS_SRST
) && (req_tlr_or_trst
)) && (req_srst
== 0))
532 if (req_srst
&& !(jtag_reset_config
& RESET_HAS_SRST
))
534 LOG_ERROR("BUG: requested SRST assertion, but the current configuration doesn't support this");
535 jtag_set_error(ERROR_FAIL
);
541 if (!trst_with_tlr
&& (jtag_reset_config
& RESET_HAS_TRST
))
553 jtag_srst
= req_srst
;
555 int retval
= interface_jtag_add_reset(jtag_trst
, jtag_srst
);
556 if (retval
!= ERROR_OK
)
558 jtag_set_error(retval
);
561 jtag_execute_queue();
565 LOG_DEBUG("SRST line asserted");
569 LOG_DEBUG("SRST line released");
570 if (jtag_nsrst_delay
)
571 jtag_add_sleep(jtag_nsrst_delay
* 1000);
576 LOG_DEBUG("JTAG reset with RESET instead of TRST");
577 jtag_set_end_state(TAP_RESET
);
584 /* we just asserted nTRST, so we're now in Test-Logic-Reset,
585 * and inform possible listeners about this
587 LOG_DEBUG("TRST line asserted");
588 tap_set_state(TAP_RESET
);
589 jtag_call_event_callbacks(JTAG_TRST_ASSERTED
);
593 if (jtag_ntrst_delay
)
594 jtag_add_sleep(jtag_ntrst_delay
* 1000);
598 tap_state_t
jtag_set_end_state(tap_state_t state
)
600 if ((state
== TAP_DRSHIFT
)||(state
== TAP_IRSHIFT
))
602 LOG_ERROR("BUG: TAP_DRSHIFT/IRSHIFT can't be end state. Calling code should use a larger scan field");
605 if (state
!=TAP_INVALID
)
606 cmd_queue_end_state
= state
;
607 return cmd_queue_end_state
;
610 tap_state_t
jtag_get_end_state(void)
612 return cmd_queue_end_state
;
615 void jtag_add_sleep(u32 us
)
617 /// @todo Here, keep_alive() appears to be a layering violation!!!
619 jtag_set_error(interface_jtag_add_sleep(us
));
622 int jtag_check_value_inner(u8
*captured
, u8
*in_check_value
, u8
*in_check_mask
, int num_bits
)
624 int retval
= ERROR_OK
;
626 int compare_failed
= 0;
629 compare_failed
= buf_cmp_mask(captured
, in_check_value
, in_check_mask
, num_bits
);
631 compare_failed
= buf_cmp(captured
, in_check_value
, num_bits
);
634 /* An error handler could have caught the failing check
635 * only report a problem when there wasn't a handler, or if the handler
636 * acknowledged the error
639 LOG_WARNING("TAP %s:",
640 jtag_tap_name(field->tap));
644 char *captured_char
= buf_to_str(captured
, (num_bits
> DEBUG_JTAG_IOZ
) ? DEBUG_JTAG_IOZ
: num_bits
, 16);
645 char *in_check_value_char
= buf_to_str(in_check_value
, (num_bits
> DEBUG_JTAG_IOZ
) ? DEBUG_JTAG_IOZ
: num_bits
, 16);
649 char *in_check_mask_char
;
650 in_check_mask_char
= buf_to_str(in_check_mask
, (num_bits
> DEBUG_JTAG_IOZ
) ? DEBUG_JTAG_IOZ
: num_bits
, 16);
651 LOG_WARNING("value captured during scan didn't pass the requested check:");
652 LOG_WARNING("captured: 0x%s check_value: 0x%s check_mask: 0x%s",
653 captured_char
, in_check_value_char
, in_check_mask_char
);
654 free(in_check_mask_char
);
658 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
);
662 free(in_check_value_char
);
664 retval
= ERROR_JTAG_QUEUE_FAILED
;
671 void jtag_check_value_mask(scan_field_t
*field
, u8
*value
, u8
*mask
)
673 assert(field
->in_value
!= NULL
);
677 /* no checking to do */
681 jtag_execute_queue_noclear();
683 int retval
=jtag_check_value_inner(field
->in_value
, value
, mask
, field
->num_bits
);
684 jtag_set_error(retval
);
689 int default_interface_jtag_execute_queue(void)
693 LOG_ERROR("No JTAG interface configured yet. "
694 "Issue 'init' command in startup scripts "
695 "before communicating with targets.");
699 return jtag
->execute_queue();
702 void jtag_execute_queue_noclear(void)
704 jtag_flush_queue_count
++;
705 jtag_set_error(interface_jtag_execute_queue());
708 int jtag_get_flush_queue_count(void)
710 return jtag_flush_queue_count
;
713 int jtag_execute_queue(void)
715 jtag_execute_queue_noclear();
716 return jtag_error_clear();
719 static int jtag_reset_callback(enum jtag_event event
, void *priv
)
721 jtag_tap_t
*tap
= priv
;
725 if (event
== JTAG_TRST_ASSERTED
)
727 buf_set_ones(tap
->cur_instr
, tap
->ir_length
);
734 void jtag_sleep(u32 us
)
736 alive_sleep(us
/1000);
739 /// maximum number of JTAG devices expected in the chain
740 #define JTAG_MAX_CHAIN_SIZE 20
742 #define EXTRACT_MFG(X) (((X) & 0xffe) >> 1)
743 #define EXTRACT_PART(X) (((X) & 0xffff000) >> 12)
744 #define EXTRACT_VER(X) (((X) & 0xf0000000) >> 28)
746 static int jtag_examine_chain_execute(u8
*idcode_buffer
, unsigned num_idcode
)
748 scan_field_t field
= {
750 .num_bits
= num_idcode
* 32,
751 .out_value
= idcode_buffer
,
752 .in_value
= idcode_buffer
,
755 // initialize to the end of chain ID value
756 for (unsigned i
= 0; i
< JTAG_MAX_CHAIN_SIZE
; i
++)
757 buf_set_u32(idcode_buffer
, i
* 32, 32, 0x000000FF);
759 jtag_add_plain_dr_scan(1, &field
, TAP_RESET
);
760 return jtag_execute_queue();
763 static bool jtag_examine_chain_check(u8
*idcodes
, unsigned count
)
768 for (unsigned i
= 0; i
< count
* 4; i
++)
770 zero_check
|= idcodes
[i
];
771 one_check
&= idcodes
[i
];
774 /* if there wasn't a single non-zero bit or if all bits were one,
775 * the scan is not valid */
776 if (zero_check
== 0x00 || one_check
== 0xff)
778 LOG_ERROR("JTAG communication failure: check connection, "
779 "JTAG interface, target power etc.");
785 static void jtag_examine_chain_display(enum log_levels level
, const char *msg
,
786 const char *name
, u32 idcode
)
788 log_printf_lf(level
, __FILE__
, __LINE__
, __FUNCTION__
,
789 "JTAG tap: %s %16.16s: 0x%08x "
790 "(mfg: 0x%3.3x, part: 0x%4.4x, ver: 0x%1.1x)",
792 EXTRACT_MFG(idcode
), EXTRACT_PART(idcode
), EXTRACT_VER(idcode
) );
795 static bool jtag_idcode_is_final(u32 idcode
)
797 return idcode
== 0x000000FF || idcode
== 0xFFFFFFFF;
801 * This helper checks that remaining bits in the examined chain data are
802 * all as expected, but a single JTAG device requires only 64 bits to be
803 * read back correctly. This can help identify and diagnose problems
804 * with the JTAG chain earlier, gives more helpful/explicit error messages.
806 static void jtag_examine_chain_end(u8
*idcodes
, unsigned count
, unsigned max
)
808 bool triggered
= false;
809 for ( ; count
< max
- 31; count
+= 32)
811 u32 idcode
= buf_get_u32(idcodes
, count
, 32);
812 // do not trigger the warning if the data looks good
813 if (!triggered
&& jtag_idcode_is_final(idcode
))
815 LOG_WARNING("Unexpected idcode after end of chain: %d 0x%08x",
821 static bool jtag_examine_chain_match_tap(const struct jtag_tap_s
*tap
)
823 if (0 == tap
->expected_ids_cnt
)
825 /// @todo Enable LOG_INFO to ask for reports about unknown TAP IDs.
827 LOG_INFO("Uknown JTAG TAP ID: 0x%08x", tap
->idcode
)
828 LOG_INFO("Please report the chip name and reported ID code to the openocd project");
833 /* Loop over the expected identification codes and test for a match */
835 for (ii
= 0; ii
< tap
->expected_ids_cnt
; ii
++)
837 if (tap
->idcode
== tap
->expected_ids
[ii
])
841 /* If none of the expected ids matched, log an error */
842 if (ii
!= tap
->expected_ids_cnt
)
844 LOG_INFO("JTAG Tap/device matched");
847 jtag_examine_chain_display(LOG_LVL_ERROR
, "got",
848 tap
->dotted_name
, tap
->idcode
);
849 for (ii
= 0; ii
< tap
->expected_ids_cnt
; ii
++)
852 snprintf(msg
, sizeof(msg
), "expected %hhu of %hhu",
853 ii
+ 1, tap
->expected_ids_cnt
);
854 jtag_examine_chain_display(LOG_LVL_ERROR
, msg
,
855 tap
->dotted_name
, tap
->expected_ids
[ii
]);
860 /* Try to examine chain layout according to IEEE 1149.1 §12
862 int jtag_examine_chain(void)
864 u8 idcode_buffer
[JTAG_MAX_CHAIN_SIZE
* 4];
865 unsigned device_count
= 0;
867 jtag_examine_chain_execute(idcode_buffer
, JTAG_MAX_CHAIN_SIZE
);
869 if (!jtag_examine_chain_check(idcode_buffer
, JTAG_MAX_CHAIN_SIZE
))
870 return ERROR_JTAG_INIT_FAILED
;
872 /* point at the 1st tap */
873 jtag_tap_t
*tap
= jtag_tap_next_enabled(NULL
);
876 LOG_ERROR("JTAG: No taps enabled?");
877 return ERROR_JTAG_INIT_FAILED
;
880 for (unsigned bit_count
= 0; bit_count
< (JTAG_MAX_CHAIN_SIZE
* 32) - 31;)
882 u32 idcode
= buf_get_u32(idcode_buffer
, bit_count
, 32);
883 if ((idcode
& 1) == 0)
885 /* LSB must not be 0, this indicates a device in bypass */
886 LOG_WARNING("Tap/Device does not have IDCODE");
894 * End of chain (invalid manufacturer ID) some devices, such
895 * as AVR will output all 1's instead of TDI input value at
898 if (jtag_idcode_is_final(idcode
))
900 jtag_examine_chain_end(idcode_buffer
,
901 bit_count
+ 32, JTAG_MAX_CHAIN_SIZE
* 32);
905 jtag_examine_chain_display(LOG_LVL_INFO
, "tap/device found",
906 tap
? tap
->dotted_name
: "(not-named)",
915 tap
->idcode
= idcode
;
917 // ensure the TAP ID does matches what was expected
918 if (!jtag_examine_chain_match_tap(tap
))
919 return ERROR_JTAG_INIT_FAILED
;
921 tap
= jtag_tap_next_enabled(tap
);
924 /* see if number of discovered devices matches configuration */
925 if (device_count
!= jtag_tap_count_enabled())
927 LOG_ERROR("number of discovered devices in JTAG chain (%i) "
928 "does not match (enabled) configuration (%i), total taps: %d",
929 device_count
, jtag_tap_count_enabled(), jtag_tap_count());
930 LOG_ERROR("check the config file and ensure proper JTAG communication"
931 " (connections, speed, ...)");
932 return ERROR_JTAG_INIT_FAILED
;
938 int jtag_validate_chain(void)
941 int total_ir_length
= 0;
949 tap
= jtag_tap_next_enabled(tap
);
953 total_ir_length
+= tap
->ir_length
;
956 total_ir_length
+= 2;
957 ir_test
= malloc(CEIL(total_ir_length
, 8));
958 buf_set_ones(ir_test
, total_ir_length
);
961 field
.num_bits
= total_ir_length
;
962 field
.out_value
= ir_test
;
963 field
.in_value
= ir_test
;
966 jtag_add_plain_ir_scan(1, &field
, TAP_RESET
);
967 jtag_execute_queue();
973 tap
= jtag_tap_next_enabled(tap
);
978 val
= buf_get_u32(ir_test
, chain_pos
, 2);
981 char *cbuf
= buf_to_str(ir_test
, total_ir_length
, 16);
982 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
);
985 return ERROR_JTAG_INIT_FAILED
;
987 chain_pos
+= tap
->ir_length
;
990 val
= buf_get_u32(ir_test
, chain_pos
, 2);
993 char *cbuf
= buf_to_str(ir_test
, total_ir_length
, 16);
994 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
);
997 return ERROR_JTAG_INIT_FAILED
;
1006 void jtag_tap_init(jtag_tap_t
*tap
)
1008 assert(0 != tap
->ir_length
);
1010 tap
->expected
= malloc(tap
->ir_length
);
1011 tap
->expected_mask
= malloc(tap
->ir_length
);
1012 tap
->cur_instr
= malloc(tap
->ir_length
);
1014 buf_set_u32(tap
->expected
, 0, tap
->ir_length
, tap
->ir_capture_value
);
1015 buf_set_u32(tap
->expected_mask
, 0, tap
->ir_length
, tap
->ir_capture_mask
);
1016 buf_set_ones(tap
->cur_instr
, tap
->ir_length
);
1018 // place TAP in bypass mode
1020 // register the reset callback for the TAP
1021 jtag_register_event_callback(&jtag_reset_callback
, tap
);
1023 LOG_DEBUG("Created Tap: %s @ abs position %d, "
1024 "irlen %d, capture: 0x%x mask: 0x%x", tap
->dotted_name
,
1025 tap
->abs_chain_position
, tap
->ir_length
,
1026 tap
->ir_capture_value
, tap
->ir_capture_mask
);
1030 void jtag_tap_free(jtag_tap_t
*tap
)
1032 /// @todo is anything missing? no memory leaks please
1033 free((void *)tap
->expected_ids
);
1034 free((void *)tap
->chip
);
1035 free((void *)tap
->tapname
);
1036 free((void *)tap
->dotted_name
);
1040 int jtag_interface_init(struct command_context_s
*cmd_ctx
)
1045 if (!jtag_interface
)
1047 /* nothing was previously specified by "interface" command */
1048 LOG_ERROR("JTAG interface has to be specified, see \"interface\" command");
1049 return ERROR_JTAG_INVALID_INTERFACE
;
1053 jtag_interface
->khz(jtag_get_speed_khz(), &jtag_speed
);
1057 if (jtag_interface
->init() != ERROR_OK
)
1058 return ERROR_JTAG_INIT_FAILED
;
1060 jtag
= jtag_interface
;
1064 static int jtag_init_inner(struct command_context_s
*cmd_ctx
)
1069 LOG_DEBUG("Init JTAG chain");
1071 tap
= jtag_tap_next_enabled(NULL
);
1073 LOG_ERROR("There are no enabled taps?");
1074 return ERROR_JTAG_INIT_FAILED
;
1078 if ((retval
=jtag_execute_queue())!=ERROR_OK
)
1081 /* examine chain first, as this could discover the real chain layout */
1082 if (jtag_examine_chain() != ERROR_OK
)
1084 LOG_ERROR("trying to validate configured JTAG chain anyway...");
1087 if (jtag_validate_chain() != ERROR_OK
)
1089 LOG_WARNING("Could not validate JTAG chain, continuing anyway...");
1095 int jtag_interface_quit(void)
1097 if (!jtag
|| !jtag
->quit
)
1100 // close the JTAG interface
1101 int result
= jtag
->quit();
1102 if (ERROR_OK
!= result
)
1103 LOG_ERROR("failed: %d", result
);
1109 int jtag_init_reset(struct command_context_s
*cmd_ctx
)
1113 if ((retval
=jtag_interface_init(cmd_ctx
)) != ERROR_OK
)
1116 LOG_DEBUG("Trying to bring the JTAG controller to life by asserting TRST / RESET");
1118 /* Reset can happen after a power cycle.
1120 * Ideally we would only assert TRST or run RESET before the target reset.
1122 * However w/srst_pulls_trst, trst is asserted together with the target
1123 * reset whether we want it or not.
1125 * NB! Some targets have JTAG circuitry disabled until a
1126 * trst & srst has been asserted.
1128 * NB! here we assume nsrst/ntrst delay are sufficient!
1130 * NB! order matters!!!! srst *can* disconnect JTAG circuitry
1133 jtag_add_reset(1, 0); /* RESET or TRST */
1134 if (jtag_reset_config
& RESET_HAS_SRST
)
1136 jtag_add_reset(1, 1);
1137 if ((jtag_reset_config
& RESET_SRST_PULLS_TRST
)==0)
1138 jtag_add_reset(0, 1);
1140 jtag_add_reset(0, 0);
1141 if ((retval
= jtag_execute_queue()) != ERROR_OK
)
1144 /* Check that we can communication on the JTAG chain + eventually we want to
1145 * be able to perform enumeration only after OpenOCD has started
1146 * telnet and GDB server
1148 * That would allow users to more easily perform any magic they need to before
1151 return jtag_init_inner(cmd_ctx
);
1154 int jtag_init(struct command_context_s
*cmd_ctx
)
1157 if ((retval
=jtag_interface_init(cmd_ctx
)) != ERROR_OK
)
1159 if (jtag_init_inner(cmd_ctx
)==ERROR_OK
)
1163 return jtag_init_reset(cmd_ctx
);
1166 void jtag_set_speed_khz(unsigned khz
)
1170 unsigned jtag_get_speed_khz(void)
1174 int jtag_get_speed(void)
1179 int jtag_set_speed(int speed
)
1182 /* this command can be called during CONFIG,
1183 * in which case jtag isn't initialized */
1185 return jtag
? jtag
->speed(speed
) : ERROR_OK
;
1188 void jtag_set_verify(bool enable
)
1190 jtag_verify
= enable
;
1193 bool jtag_will_verify()
1198 void jtag_set_verify_capture_ir(bool enable
)
1200 jtag_verify_capture_ir
= enable
;
1203 bool jtag_will_verify_capture_ir()
1205 return jtag_verify_capture_ir
;
1208 int jtag_power_dropout(int *dropout
)
1210 return jtag
->power_dropout(dropout
);
1213 int jtag_srst_asserted(int *srst_asserted
)
1215 return jtag
->srst_asserted(srst_asserted
);
1218 int jtag_add_statemove(tap_state_t goal_state
)
1220 tap_state_t cur_state
= cmd_queue_cur_state
;
1222 LOG_DEBUG( "cur_state=%s goal_state=%s",
1223 tap_state_name(cur_state
),
1224 tap_state_name(goal_state
) );
1227 if (goal_state
==cur_state
)
1228 ; /* nothing to do */
1229 else if( goal_state
==TAP_RESET
)
1233 else if( tap_is_state_stable(cur_state
) && tap_is_state_stable(goal_state
) )
1235 unsigned tms_bits
= tap_get_tms_path(cur_state
, goal_state
);
1236 unsigned tms_count
= tap_get_tms_path_len(cur_state
, goal_state
);
1237 tap_state_t moves
[8];
1238 assert(tms_count
< DIM(moves
));
1240 for (unsigned i
= 0; i
< tms_count
; i
++, tms_bits
>>= 1)
1242 bool bit
= tms_bits
& 1;
1244 cur_state
= tap_state_transition(cur_state
, bit
);
1245 moves
[i
] = cur_state
;
1248 jtag_add_pathmove(tms_count
, moves
);
1250 else if( tap_state_transition(cur_state
, true) == goal_state
1251 || tap_state_transition(cur_state
, false) == goal_state
)
1253 jtag_add_pathmove(1, &goal_state
);
1262 enum reset_types
jtag_get_reset_config(void)
1264 return jtag_reset_config
;
1266 void jtag_set_reset_config(enum reset_types type
)
1268 jtag_reset_config
= type
;
1271 int jtag_get_trst(void)
1275 int jtag_get_srst(void)
1280 void jtag_set_nsrst_delay(unsigned delay
)
1282 jtag_nsrst_delay
= delay
;
1284 unsigned jtag_get_nsrst_delay(void)
1286 return jtag_nsrst_delay
;
1288 void jtag_set_ntrst_delay(unsigned delay
)
1290 jtag_ntrst_delay
= delay
;
1292 unsigned jtag_get_ntrst_delay(void)
1294 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)