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 typedef struct jtag_event_callback_s
92 jtag_event_handler_t callback
;
94 struct jtag_event_callback_s
* next
;
95 } jtag_event_callback_t
;
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 static 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 if (parse_uint(s
, &n
) != ERROR_OK
)
179 return jtag_tap_by_position(n
);
182 jtag_tap_t
*jtag_tap_by_jim_obj(Jim_Interp
*interp
, Jim_Obj
*o
)
184 const char *cp
= Jim_GetString(o
, NULL
);
185 jtag_tap_t
*t
= cp
? jtag_tap_by_string(cp
) : NULL
;
189 Jim_SetResult_sprintf(interp
, "Tap '%s' could not be found", cp
);
193 /* returns a pointer to the n-th device in the scan chain */
194 jtag_tap_t
*jtag_tap_by_position(unsigned n
)
196 jtag_tap_t
*t
= jtag_all_taps();
204 jtag_tap_t
* jtag_tap_next_enabled(jtag_tap_t
* p
)
206 p
= p
? p
->next_tap
: jtag_all_taps();
216 const char *jtag_tap_name(const jtag_tap_t
*tap
)
218 return (tap
== NULL
) ? "(unknown)" : tap
->dotted_name
;
222 int jtag_register_event_callback(jtag_event_handler_t callback
, void *priv
)
224 jtag_event_callback_t
**callbacks_p
= &jtag_event_callbacks
;
226 if (callback
== NULL
)
228 return ERROR_INVALID_ARGUMENTS
;
233 while ((*callbacks_p
)->next
)
234 callbacks_p
= &((*callbacks_p
)->next
);
235 callbacks_p
= &((*callbacks_p
)->next
);
238 (*callbacks_p
) = malloc(sizeof(jtag_event_callback_t
));
239 (*callbacks_p
)->callback
= callback
;
240 (*callbacks_p
)->priv
= priv
;
241 (*callbacks_p
)->next
= NULL
;
246 int jtag_unregister_event_callback(jtag_event_handler_t callback
)
248 jtag_event_callback_t
**callbacks_p
= &jtag_event_callbacks
;
250 if (callback
== NULL
)
252 return ERROR_INVALID_ARGUMENTS
;
257 jtag_event_callback_t
**next
= &((*callbacks_p
)->next
);
258 if ((*callbacks_p
)->callback
== callback
)
261 *callbacks_p
= *next
;
269 int jtag_call_event_callbacks(enum jtag_event event
)
271 jtag_event_callback_t
*callback
= jtag_event_callbacks
;
273 LOG_DEBUG("jtag event: %s", jtag_event_strings
[event
]);
277 callback
->callback(event
, callback
->priv
);
278 callback
= callback
->next
;
284 static void jtag_checks(void)
286 assert(jtag_trst
== 0);
289 static void jtag_prelude(tap_state_t state
)
293 assert(state
!=TAP_INVALID
);
295 cmd_queue_cur_state
= state
;
298 void jtag_alloc_in_value32(scan_field_t
*field
)
300 interface_jtag_alloc_in_value32(field
);
303 void jtag_add_ir_scan_noverify(int in_count
, const scan_field_t
*in_fields
,
308 int retval
= interface_jtag_add_ir_scan(in_count
, in_fields
, state
);
309 jtag_set_error(retval
);
313 void jtag_add_ir_scan(int in_num_fields
, scan_field_t
*in_fields
, tap_state_t state
)
315 if (jtag_verify
&&jtag_verify_capture_ir
)
317 /* 8 x 32 bit id's is enough for all invocations */
319 for (int j
= 0; j
< in_num_fields
; j
++)
321 /* if we are to run a verification of the ir scan, we need to get the input back.
322 * We may have to allocate space if the caller didn't ask for the input back.
324 in_fields
[j
].check_value
=in_fields
[j
].tap
->expected
;
325 in_fields
[j
].check_mask
=in_fields
[j
].tap
->expected_mask
;
327 jtag_add_scan_check(jtag_add_ir_scan_noverify
, in_num_fields
, in_fields
, state
);
330 jtag_add_ir_scan_noverify(in_num_fields
, in_fields
, state
);
334 void jtag_add_plain_ir_scan(int in_num_fields
, const scan_field_t
*in_fields
,
339 int retval
= interface_jtag_add_plain_ir_scan(
340 in_num_fields
, in_fields
, state
);
341 jtag_set_error(retval
);
344 void jtag_add_callback(jtag_callback1_t f
, u8
*in
)
346 interface_jtag_add_callback(f
, in
);
349 void jtag_add_callback4(jtag_callback_t f
, u8
*in
,
350 jtag_callback_data_t data1
, jtag_callback_data_t data2
,
351 jtag_callback_data_t data3
)
353 interface_jtag_add_callback4(f
, in
, data1
, data2
, data3
);
356 int jtag_check_value_inner(u8
*captured
, u8
*in_check_value
, u8
*in_check_mask
, int num_bits
);
358 static int jtag_check_value_mask_callback(u8
*in
, jtag_callback_data_t data1
, jtag_callback_data_t data2
, jtag_callback_data_t data3
)
360 return jtag_check_value_inner(in
, (u8
*)data1
, (u8
*)data2
, (int)data3
);
363 static void jtag_add_scan_check(void (*jtag_add_scan
)(int in_num_fields
, const scan_field_t
*in_fields
, tap_state_t state
),
364 int in_num_fields
, scan_field_t
*in_fields
, tap_state_t state
)
366 for (int i
= 0; i
< in_num_fields
; i
++)
368 struct scan_field_s
*field
= &in_fields
[i
];
369 field
->allocated
= 0;
371 if (field
->check_value
|| field
->in_value
)
373 interface_jtag_add_scan_check_alloc(field
);
377 jtag_add_scan(in_num_fields
, in_fields
, state
);
379 for (int i
= 0; i
< in_num_fields
; i
++)
381 if ((in_fields
[i
].check_value
!= NULL
) && (in_fields
[i
].in_value
!= NULL
))
383 /* this is synchronous for a minidriver */
384 jtag_add_callback4(jtag_check_value_mask_callback
, in_fields
[i
].in_value
,
385 (jtag_callback_data_t
)in_fields
[i
].check_value
,
386 (jtag_callback_data_t
)in_fields
[i
].check_mask
,
387 (jtag_callback_data_t
)in_fields
[i
].num_bits
);
389 if (in_fields
[i
].allocated
)
391 free(in_fields
[i
].in_value
);
393 if (in_fields
[i
].modified
)
395 in_fields
[i
].in_value
= NULL
;
400 void jtag_add_dr_scan_check(int in_num_fields
, scan_field_t
*in_fields
, tap_state_t state
)
404 jtag_add_scan_check(jtag_add_dr_scan
, in_num_fields
, in_fields
, state
);
407 jtag_add_dr_scan(in_num_fields
, in_fields
, state
);
412 void jtag_add_dr_scan(int in_num_fields
, const scan_field_t
*in_fields
,
418 retval
= interface_jtag_add_dr_scan(in_num_fields
, in_fields
, state
);
419 jtag_set_error(retval
);
422 void jtag_add_plain_dr_scan(int in_num_fields
, const scan_field_t
*in_fields
,
428 retval
= interface_jtag_add_plain_dr_scan(in_num_fields
, in_fields
, state
);
429 jtag_set_error(retval
);
432 void jtag_add_dr_out(jtag_tap_t
* tap
,
433 int num_fields
, const int* num_bits
, const u32
* value
,
434 tap_state_t end_state
)
436 assert(end_state
!= TAP_INVALID
);
438 cmd_queue_cur_state
= end_state
;
440 interface_jtag_add_dr_out(tap
,
441 num_fields
, num_bits
, value
,
445 void jtag_add_tlr(void)
447 jtag_prelude(TAP_RESET
);
448 jtag_set_error(interface_jtag_add_tlr());
449 jtag_call_event_callbacks(JTAG_TRST_ASSERTED
);
452 void jtag_add_pathmove(int num_states
, const tap_state_t
*path
)
454 tap_state_t cur_state
= cmd_queue_cur_state
;
456 /* the last state has to be a stable state */
457 if (!tap_is_state_stable(path
[num_states
- 1]))
459 LOG_ERROR("BUG: TAP path doesn't finish in a stable state");
460 jtag_set_error(ERROR_JTAG_NOT_STABLE_STATE
);
464 for (int i
= 0; i
< num_states
; i
++)
466 if (path
[i
] == TAP_RESET
)
468 LOG_ERROR("BUG: TAP_RESET is not a valid state for pathmove sequences");
469 jtag_set_error(ERROR_JTAG_STATE_INVALID
);
473 if ( tap_state_transition(cur_state
, true) != path
[i
]
474 && tap_state_transition(cur_state
, false) != path
[i
])
476 LOG_ERROR("BUG: %s -> %s isn't a valid TAP transition",
477 tap_state_name(cur_state
), tap_state_name(path
[i
]));
478 jtag_set_error(ERROR_JTAG_TRANSITION_INVALID
);
486 jtag_set_error(interface_jtag_add_pathmove(num_states
, path
));
487 cmd_queue_cur_state
= path
[num_states
- 1];
490 int jtag_add_statemove(tap_state_t goal_state
)
492 tap_state_t cur_state
= cmd_queue_cur_state
;
494 LOG_DEBUG( "cur_state=%s goal_state=%s",
495 tap_state_name(cur_state
),
496 tap_state_name(goal_state
) );
499 if (goal_state
==cur_state
)
500 ; /* nothing to do */
501 else if( goal_state
==TAP_RESET
)
505 else if( tap_is_state_stable(cur_state
) && tap_is_state_stable(goal_state
) )
507 unsigned tms_bits
= tap_get_tms_path(cur_state
, goal_state
);
508 unsigned tms_count
= tap_get_tms_path_len(cur_state
, goal_state
);
509 tap_state_t moves
[8];
510 assert(tms_count
< DIM(moves
));
512 for (unsigned i
= 0; i
< tms_count
; i
++, tms_bits
>>= 1)
514 bool bit
= tms_bits
& 1;
516 cur_state
= tap_state_transition(cur_state
, bit
);
517 moves
[i
] = cur_state
;
520 jtag_add_pathmove(tms_count
, moves
);
522 else if( tap_state_transition(cur_state
, true) == goal_state
523 || tap_state_transition(cur_state
, false) == goal_state
)
525 jtag_add_pathmove(1, &goal_state
);
534 void jtag_add_runtest(int num_cycles
, tap_state_t state
)
537 jtag_set_error(interface_jtag_add_runtest(num_cycles
, state
));
541 void jtag_add_clocks(int num_cycles
)
543 if (!tap_is_state_stable(cmd_queue_cur_state
))
545 LOG_ERROR("jtag_add_clocks() called with TAP in unstable state \"%s\"",
546 tap_state_name(cmd_queue_cur_state
));
547 jtag_set_error(ERROR_JTAG_NOT_STABLE_STATE
);
554 jtag_set_error(interface_jtag_add_clocks(num_cycles
));
558 void jtag_add_reset(int req_tlr_or_trst
, int req_srst
)
560 int trst_with_tlr
= 0;
562 /* FIX!!! there are *many* different cases here. A better
563 * approach is needed for legal combinations of transitions...
565 if ((jtag_reset_config
& RESET_HAS_SRST
)&&
566 (jtag_reset_config
& RESET_HAS_TRST
)&&
567 ((jtag_reset_config
& RESET_SRST_PULLS_TRST
)==0))
569 if (((req_tlr_or_trst
&&!jtag_trst
)||
570 (!req_tlr_or_trst
&&jtag_trst
))&&
571 ((req_srst
&&!jtag_srst
)||
572 (!req_srst
&&jtag_srst
)))
574 /* FIX!!! srst_pulls_trst allows 1,1 => 0,0 transition.... */
575 //LOG_ERROR("BUG: transition of req_tlr_or_trst and req_srst in the same jtag_add_reset() call is undefined");
579 /* Make sure that jtag_reset_config allows the requested reset */
580 /* if SRST pulls TRST, we can't fulfill srst == 1 with trst == 0 */
581 if (((jtag_reset_config
& RESET_SRST_PULLS_TRST
) && (req_srst
== 1)) && (!req_tlr_or_trst
))
583 LOG_ERROR("BUG: requested reset would assert trst");
584 jtag_set_error(ERROR_FAIL
);
588 /* if TRST pulls SRST, we reset with TAP T-L-R */
589 if (((jtag_reset_config
& RESET_TRST_PULLS_SRST
) && (req_tlr_or_trst
)) && (req_srst
== 0))
594 if (req_srst
&& !(jtag_reset_config
& RESET_HAS_SRST
))
596 LOG_ERROR("BUG: requested SRST assertion, but the current configuration doesn't support this");
597 jtag_set_error(ERROR_FAIL
);
603 if (!trst_with_tlr
&& (jtag_reset_config
& RESET_HAS_TRST
))
615 jtag_srst
= req_srst
;
617 int retval
= interface_jtag_add_reset(jtag_trst
, jtag_srst
);
618 if (retval
!= ERROR_OK
)
620 jtag_set_error(retval
);
623 jtag_execute_queue();
627 LOG_DEBUG("SRST line asserted");
631 LOG_DEBUG("SRST line released");
632 if (jtag_nsrst_delay
)
633 jtag_add_sleep(jtag_nsrst_delay
* 1000);
638 LOG_DEBUG("JTAG reset with RESET instead of TRST");
639 jtag_set_end_state(TAP_RESET
);
646 /* we just asserted nTRST, so we're now in Test-Logic-Reset,
647 * and inform possible listeners about this
649 LOG_DEBUG("TRST line asserted");
650 tap_set_state(TAP_RESET
);
651 jtag_call_event_callbacks(JTAG_TRST_ASSERTED
);
655 if (jtag_ntrst_delay
)
656 jtag_add_sleep(jtag_ntrst_delay
* 1000);
660 tap_state_t
jtag_set_end_state(tap_state_t state
)
662 if ((state
== TAP_DRSHIFT
)||(state
== TAP_IRSHIFT
))
664 LOG_ERROR("BUG: TAP_DRSHIFT/IRSHIFT can't be end state. Calling code should use a larger scan field");
667 if (state
!=TAP_INVALID
)
668 cmd_queue_end_state
= state
;
669 return cmd_queue_end_state
;
672 tap_state_t
jtag_get_end_state(void)
674 return cmd_queue_end_state
;
677 void jtag_add_sleep(u32 us
)
679 /// @todo Here, keep_alive() appears to be a layering violation!!!
681 jtag_set_error(interface_jtag_add_sleep(us
));
684 int jtag_check_value_inner(u8
*captured
, u8
*in_check_value
, u8
*in_check_mask
, int num_bits
)
686 int retval
= ERROR_OK
;
688 int compare_failed
= 0;
691 compare_failed
= buf_cmp_mask(captured
, in_check_value
, in_check_mask
, num_bits
);
693 compare_failed
= buf_cmp(captured
, in_check_value
, num_bits
);
696 /* An error handler could have caught the failing check
697 * only report a problem when there wasn't a handler, or if the handler
698 * acknowledged the error
701 LOG_WARNING("TAP %s:",
702 jtag_tap_name(field->tap));
706 char *captured_char
= buf_to_str(captured
, (num_bits
> DEBUG_JTAG_IOZ
) ? DEBUG_JTAG_IOZ
: num_bits
, 16);
707 char *in_check_value_char
= buf_to_str(in_check_value
, (num_bits
> DEBUG_JTAG_IOZ
) ? DEBUG_JTAG_IOZ
: num_bits
, 16);
711 char *in_check_mask_char
;
712 in_check_mask_char
= buf_to_str(in_check_mask
, (num_bits
> DEBUG_JTAG_IOZ
) ? DEBUG_JTAG_IOZ
: num_bits
, 16);
713 LOG_WARNING("value captured during scan didn't pass the requested check:");
714 LOG_WARNING("captured: 0x%s check_value: 0x%s check_mask: 0x%s",
715 captured_char
, in_check_value_char
, in_check_mask_char
);
716 free(in_check_mask_char
);
720 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
);
724 free(in_check_value_char
);
726 retval
= ERROR_JTAG_QUEUE_FAILED
;
733 void jtag_check_value_mask(scan_field_t
*field
, u8
*value
, u8
*mask
)
735 assert(field
->in_value
!= NULL
);
739 /* no checking to do */
743 jtag_execute_queue_noclear();
745 int retval
=jtag_check_value_inner(field
->in_value
, value
, mask
, field
->num_bits
);
746 jtag_set_error(retval
);
751 int default_interface_jtag_execute_queue(void)
755 LOG_ERROR("No JTAG interface configured yet. "
756 "Issue 'init' command in startup scripts "
757 "before communicating with targets.");
761 return jtag
->execute_queue();
764 void jtag_execute_queue_noclear(void)
766 jtag_flush_queue_count
++;
767 jtag_set_error(interface_jtag_execute_queue());
770 int jtag_get_flush_queue_count(void)
772 return jtag_flush_queue_count
;
775 int jtag_execute_queue(void)
777 jtag_execute_queue_noclear();
778 return jtag_error_clear();
781 static int jtag_reset_callback(enum jtag_event event
, void *priv
)
783 jtag_tap_t
*tap
= priv
;
787 if (event
== JTAG_TRST_ASSERTED
)
789 buf_set_ones(tap
->cur_instr
, tap
->ir_length
);
796 void jtag_sleep(u32 us
)
798 alive_sleep(us
/1000);
801 /// maximum number of JTAG devices expected in the chain
802 #define JTAG_MAX_CHAIN_SIZE 20
804 #define EXTRACT_MFG(X) (((X) & 0xffe) >> 1)
805 #define EXTRACT_PART(X) (((X) & 0xffff000) >> 12)
806 #define EXTRACT_VER(X) (((X) & 0xf0000000) >> 28)
808 static int jtag_examine_chain_execute(u8
*idcode_buffer
, unsigned num_idcode
)
810 scan_field_t field
= {
812 .num_bits
= num_idcode
* 32,
813 .out_value
= idcode_buffer
,
814 .in_value
= idcode_buffer
,
817 // initialize to the end of chain ID value
818 for (unsigned i
= 0; i
< JTAG_MAX_CHAIN_SIZE
; i
++)
819 buf_set_u32(idcode_buffer
, i
* 32, 32, 0x000000FF);
821 jtag_add_plain_dr_scan(1, &field
, TAP_RESET
);
822 return jtag_execute_queue();
825 static bool jtag_examine_chain_check(u8
*idcodes
, unsigned count
)
830 for (unsigned i
= 0; i
< count
* 4; i
++)
832 zero_check
|= idcodes
[i
];
833 one_check
&= idcodes
[i
];
836 /* if there wasn't a single non-zero bit or if all bits were one,
837 * the scan is not valid */
838 if (zero_check
== 0x00 || one_check
== 0xff)
840 LOG_ERROR("JTAG communication failure: check connection, "
841 "JTAG interface, target power etc.");
847 static void jtag_examine_chain_display(enum log_levels level
, const char *msg
,
848 const char *name
, u32 idcode
)
850 log_printf_lf(level
, __FILE__
, __LINE__
, __FUNCTION__
,
851 "JTAG tap: %s %16.16s: 0x%08x "
852 "(mfg: 0x%3.3x, part: 0x%4.4x, ver: 0x%1.1x)",
854 EXTRACT_MFG(idcode
), EXTRACT_PART(idcode
), EXTRACT_VER(idcode
) );
857 static bool jtag_idcode_is_final(u32 idcode
)
859 return idcode
== 0x000000FF || idcode
== 0xFFFFFFFF;
863 * This helper checks that remaining bits in the examined chain data are
864 * all as expected, but a single JTAG device requires only 64 bits to be
865 * read back correctly. This can help identify and diagnose problems
866 * with the JTAG chain earlier, gives more helpful/explicit error messages.
868 static void jtag_examine_chain_end(u8
*idcodes
, unsigned count
, unsigned max
)
870 bool triggered
= false;
871 for ( ; count
< max
- 31; count
+= 32)
873 u32 idcode
= buf_get_u32(idcodes
, count
, 32);
874 // do not trigger the warning if the data looks good
875 if (!triggered
&& jtag_idcode_is_final(idcode
))
877 LOG_WARNING("Unexpected idcode after end of chain: %d 0x%08x",
883 static bool jtag_examine_chain_match_tap(const struct jtag_tap_s
*tap
)
885 if (0 == tap
->expected_ids_cnt
)
887 /// @todo Enable LOG_INFO to ask for reports about unknown TAP IDs.
889 LOG_INFO("Uknown JTAG TAP ID: 0x%08x", tap
->idcode
)
890 LOG_INFO("Please report the chip name and reported ID code to the openocd project");
895 /* Loop over the expected identification codes and test for a match */
897 for (ii
= 0; ii
< tap
->expected_ids_cnt
; ii
++)
899 if (tap
->idcode
== tap
->expected_ids
[ii
])
903 /* If none of the expected ids matched, log an error */
904 if (ii
!= tap
->expected_ids_cnt
)
906 LOG_INFO("JTAG Tap/device matched");
909 jtag_examine_chain_display(LOG_LVL_ERROR
, "got",
910 tap
->dotted_name
, tap
->idcode
);
911 for (ii
= 0; ii
< tap
->expected_ids_cnt
; ii
++)
914 snprintf(msg
, sizeof(msg
), "expected %hhu of %hhu",
915 ii
+ 1, tap
->expected_ids_cnt
);
916 jtag_examine_chain_display(LOG_LVL_ERROR
, msg
,
917 tap
->dotted_name
, tap
->expected_ids
[ii
]);
922 /* Try to examine chain layout according to IEEE 1149.1 §12
924 int jtag_examine_chain(void)
926 u8 idcode_buffer
[JTAG_MAX_CHAIN_SIZE
* 4];
927 unsigned device_count
= 0;
929 jtag_examine_chain_execute(idcode_buffer
, JTAG_MAX_CHAIN_SIZE
);
931 if (!jtag_examine_chain_check(idcode_buffer
, JTAG_MAX_CHAIN_SIZE
))
932 return ERROR_JTAG_INIT_FAILED
;
934 /* point at the 1st tap */
935 jtag_tap_t
*tap
= jtag_tap_next_enabled(NULL
);
938 LOG_ERROR("JTAG: No taps enabled?");
939 return ERROR_JTAG_INIT_FAILED
;
942 for (unsigned bit_count
= 0; bit_count
< (JTAG_MAX_CHAIN_SIZE
* 32) - 31;)
944 u32 idcode
= buf_get_u32(idcode_buffer
, bit_count
, 32);
945 if ((idcode
& 1) == 0)
947 /* LSB must not be 0, this indicates a device in bypass */
948 LOG_WARNING("Tap/Device does not have IDCODE");
956 * End of chain (invalid manufacturer ID) some devices, such
957 * as AVR will output all 1's instead of TDI input value at
960 if (jtag_idcode_is_final(idcode
))
962 jtag_examine_chain_end(idcode_buffer
,
963 bit_count
+ 32, JTAG_MAX_CHAIN_SIZE
* 32);
967 jtag_examine_chain_display(LOG_LVL_INFO
, "tap/device found",
968 tap
? tap
->dotted_name
: "(not-named)",
977 tap
->idcode
= idcode
;
979 // ensure the TAP ID does matches what was expected
980 if (!jtag_examine_chain_match_tap(tap
))
981 return ERROR_JTAG_INIT_FAILED
;
983 tap
= jtag_tap_next_enabled(tap
);
986 /* see if number of discovered devices matches configuration */
987 if (device_count
!= jtag_tap_count_enabled())
989 LOG_ERROR("number of discovered devices in JTAG chain (%i) "
990 "does not match (enabled) configuration (%i), total taps: %d",
991 device_count
, jtag_tap_count_enabled(), jtag_tap_count());
992 LOG_ERROR("check the config file and ensure proper JTAG communication"
993 " (connections, speed, ...)");
994 return ERROR_JTAG_INIT_FAILED
;
1000 int jtag_validate_chain(void)
1003 int total_ir_length
= 0;
1009 total_ir_length
= 0;
1011 tap
= jtag_tap_next_enabled(tap
);
1015 total_ir_length
+= tap
->ir_length
;
1018 total_ir_length
+= 2;
1019 ir_test
= malloc(CEIL(total_ir_length
, 8));
1020 buf_set_ones(ir_test
, total_ir_length
);
1023 field
.num_bits
= total_ir_length
;
1024 field
.out_value
= ir_test
;
1025 field
.in_value
= ir_test
;
1028 jtag_add_plain_ir_scan(1, &field
, TAP_RESET
);
1029 jtag_execute_queue();
1035 tap
= jtag_tap_next_enabled(tap
);
1040 val
= buf_get_u32(ir_test
, chain_pos
, 2);
1043 char *cbuf
= buf_to_str(ir_test
, total_ir_length
, 16);
1044 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
);
1047 return ERROR_JTAG_INIT_FAILED
;
1049 chain_pos
+= tap
->ir_length
;
1052 val
= buf_get_u32(ir_test
, chain_pos
, 2);
1055 char *cbuf
= buf_to_str(ir_test
, total_ir_length
, 16);
1056 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
);
1059 return ERROR_JTAG_INIT_FAILED
;
1068 void jtag_tap_init(jtag_tap_t
*tap
)
1070 assert(0 != tap
->ir_length
);
1072 tap
->expected
= malloc(tap
->ir_length
);
1073 tap
->expected_mask
= malloc(tap
->ir_length
);
1074 tap
->cur_instr
= malloc(tap
->ir_length
);
1076 buf_set_u32(tap
->expected
, 0, tap
->ir_length
, tap
->ir_capture_value
);
1077 buf_set_u32(tap
->expected_mask
, 0, tap
->ir_length
, tap
->ir_capture_mask
);
1078 buf_set_ones(tap
->cur_instr
, tap
->ir_length
);
1080 // place TAP in bypass mode
1082 // register the reset callback for the TAP
1083 jtag_register_event_callback(&jtag_reset_callback
, tap
);
1085 LOG_DEBUG("Created Tap: %s @ abs position %d, "
1086 "irlen %d, capture: 0x%x mask: 0x%x", tap
->dotted_name
,
1087 tap
->abs_chain_position
, tap
->ir_length
,
1088 tap
->ir_capture_value
, tap
->ir_capture_mask
);
1092 void jtag_tap_free(jtag_tap_t
*tap
)
1094 /// @todo is anything missing? no memory leaks please
1095 free((void *)tap
->expected_ids
);
1096 free((void *)tap
->chip
);
1097 free((void *)tap
->tapname
);
1098 free((void *)tap
->dotted_name
);
1102 int jtag_interface_init(struct command_context_s
*cmd_ctx
)
1107 if (!jtag_interface
)
1109 /* nothing was previously specified by "interface" command */
1110 LOG_ERROR("JTAG interface has to be specified, see \"interface\" command");
1111 return ERROR_JTAG_INVALID_INTERFACE
;
1115 jtag_interface
->khz(jtag_get_speed_khz(), &jtag_speed
);
1119 if (jtag_interface
->init() != ERROR_OK
)
1120 return ERROR_JTAG_INIT_FAILED
;
1122 jtag
= jtag_interface
;
1126 static int jtag_init_inner(struct command_context_s
*cmd_ctx
)
1131 LOG_DEBUG("Init JTAG chain");
1133 tap
= jtag_tap_next_enabled(NULL
);
1135 LOG_ERROR("There are no enabled taps?");
1136 return ERROR_JTAG_INIT_FAILED
;
1140 if ((retval
=jtag_execute_queue())!=ERROR_OK
)
1143 /* examine chain first, as this could discover the real chain layout */
1144 if (jtag_examine_chain() != ERROR_OK
)
1146 LOG_ERROR("trying to validate configured JTAG chain anyway...");
1149 if (jtag_validate_chain() != ERROR_OK
)
1151 LOG_WARNING("Could not validate JTAG chain, continuing anyway...");
1157 int jtag_interface_quit(void)
1159 if (!jtag
|| !jtag
->quit
)
1162 // close the JTAG interface
1163 int result
= jtag
->quit();
1164 if (ERROR_OK
!= result
)
1165 LOG_ERROR("failed: %d", result
);
1171 int jtag_init_reset(struct command_context_s
*cmd_ctx
)
1175 if ((retval
=jtag_interface_init(cmd_ctx
)) != ERROR_OK
)
1178 LOG_DEBUG("Trying to bring the JTAG controller to life by asserting TRST / RESET");
1180 /* Reset can happen after a power cycle.
1182 * Ideally we would only assert TRST or run RESET before the target reset.
1184 * However w/srst_pulls_trst, trst is asserted together with the target
1185 * reset whether we want it or not.
1187 * NB! Some targets have JTAG circuitry disabled until a
1188 * trst & srst has been asserted.
1190 * NB! here we assume nsrst/ntrst delay are sufficient!
1192 * NB! order matters!!!! srst *can* disconnect JTAG circuitry
1195 jtag_add_reset(1, 0); /* RESET or TRST */
1196 if (jtag_reset_config
& RESET_HAS_SRST
)
1198 jtag_add_reset(1, 1);
1199 if ((jtag_reset_config
& RESET_SRST_PULLS_TRST
)==0)
1200 jtag_add_reset(0, 1);
1202 jtag_add_reset(0, 0);
1203 if ((retval
= jtag_execute_queue()) != ERROR_OK
)
1206 /* Check that we can communication on the JTAG chain + eventually we want to
1207 * be able to perform enumeration only after OpenOCD has started
1208 * telnet and GDB server
1210 * That would allow users to more easily perform any magic they need to before
1213 return jtag_init_inner(cmd_ctx
);
1216 int jtag_init(struct command_context_s
*cmd_ctx
)
1219 if ((retval
=jtag_interface_init(cmd_ctx
)) != ERROR_OK
)
1221 if (jtag_init_inner(cmd_ctx
)==ERROR_OK
)
1225 return jtag_init_reset(cmd_ctx
);
1228 void jtag_set_speed_khz(unsigned khz
)
1232 unsigned jtag_get_speed_khz(void)
1236 int jtag_config_khz(unsigned khz
)
1238 LOG_DEBUG("handle jtag khz");
1239 jtag_set_speed_khz(khz
);
1244 LOG_DEBUG("have interface set up");
1246 int retval
= jtag
->khz(jtag_get_speed_khz(), &speed_div1
);
1247 if (ERROR_OK
!= retval
)
1249 jtag_set_speed_khz(0);
1252 cur_speed
= speed_div1
;
1254 return jtag_set_speed(cur_speed
);
1257 int jtag_get_speed(void)
1262 int jtag_set_speed(int speed
)
1265 /* this command can be called during CONFIG,
1266 * in which case jtag isn't initialized */
1268 return jtag
? jtag
->speed(speed
) : ERROR_OK
;
1271 int jtag_get_speed_readable(int *speed
)
1273 return jtag
? jtag
->speed_div(jtag_get_speed(), speed
) : ERROR_OK
;
1277 void jtag_set_verify(bool enable
)
1279 jtag_verify
= enable
;
1282 bool jtag_will_verify()
1287 void jtag_set_verify_capture_ir(bool enable
)
1289 jtag_verify_capture_ir
= enable
;
1292 bool jtag_will_verify_capture_ir()
1294 return jtag_verify_capture_ir
;
1297 int jtag_power_dropout(int *dropout
)
1299 return jtag
->power_dropout(dropout
);
1302 int jtag_srst_asserted(int *srst_asserted
)
1304 return jtag
->srst_asserted(srst_asserted
);
1307 enum reset_types
jtag_get_reset_config(void)
1309 return jtag_reset_config
;
1311 void jtag_set_reset_config(enum reset_types type
)
1313 jtag_reset_config
= type
;
1316 int jtag_get_trst(void)
1320 int jtag_get_srst(void)
1325 void jtag_set_nsrst_delay(unsigned delay
)
1327 jtag_nsrst_delay
= delay
;
1329 unsigned jtag_get_nsrst_delay(void)
1331 return jtag_nsrst_delay
;
1333 void jtag_set_ntrst_delay(unsigned delay
)
1335 jtag_ntrst_delay
= delay
;
1337 unsigned jtag_get_ntrst_delay(void)
1339 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)