Code Review / openocd.git / blob
? search:
summary | shortlog | log | commit | commitdiff | review | tree
history | raw | HEAD
Clean up jtag command queue handling:
[openocd.git] / src / jtag / jtag.c
1 /***************************************************************************
2 * Copyright (C) 2005 by Dominic Rath *
3 * Dominic.Rath@gmx.de *
4 * *
5 * Copyright (C) 2007,2008 Øyvind Harboe *
6 * oyvind.harboe@zylin.com *
7 * *
8 * Copyright (C) 2009 SoftPLC Corporation *
9 * http://softplc.com *
10 * dick@softplc.com *
11 * *
12 * This program is free software; you can redistribute it and/or modify *
13 * it under the terms of the GNU General Public License as published by *
14 * the Free Software Foundation; either version 2 of the License, or *
15 * (at your option) any later version. *
16 * *
17 * This program is distributed in the hope that it will be useful, *
18 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
20 * GNU General Public License for more details. *
21 * *
22 * You should have received a copy of the GNU General Public License *
23 * along with this program; if not, write to the *
24 * Free Software Foundation, Inc., *
25 * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
26 ***************************************************************************/
27 #ifdef HAVE_CONFIG_H
28 #include "config.h"
29 #endif
30
31 #define INCLUDE_JTAG_MINIDRIVER_H
32 #define INCLUDE_JTAG_INTERFACE_H
33 #include "jtag.h"
34
35 #ifdef HAVE_STRINGS_H
36 #include <strings.h>
37 #endif
38
39
40 int jtag_flush_queue_count; /* count # of flushes for profiling / debugging purposes */
41
42 static void jtag_add_scan_check(void (*jtag_add_scan)(int in_num_fields, const scan_field_t *in_fields, tap_state_t state),
43 int in_num_fields, scan_field_t *in_fields, tap_state_t state);
44
45 /* note that this is not marked as static as it must be available from outside jtag.c for those
46 that implement the jtag_xxx() minidriver layer
47 */
48 int jtag_error=ERROR_OK;
49
50 typedef struct cmd_queue_page_s
51 {
52 void *address;
53 size_t used;
54 struct cmd_queue_page_s *next;
55 } cmd_queue_page_t;
56
57 #define CMD_QUEUE_PAGE_SIZE (1024 * 1024)
58 static cmd_queue_page_t *cmd_queue_pages = NULL;
59
60 char* jtag_event_strings[] =
61 {
62 "JTAG controller reset (RESET or TRST)"
63 };
64
65 const Jim_Nvp nvp_jtag_tap_event[] = {
66 { .value = JTAG_TAP_EVENT_ENABLE, .name = "tap-enable" },
67 { .value = JTAG_TAP_EVENT_DISABLE, .name = "tap-disable" },
68
69 { .name = NULL, .value = -1 }
70 };
71
72 int jtag_trst = 0;
73 int jtag_srst = 0;
74
75 #ifndef HAVE_JTAG_MINIDRIVER_H
76 struct jtag_callback_entry
77 {
78 struct jtag_callback_entry *next;
79
80 jtag_callback_t callback;
81 u8 *in;
82 jtag_callback_data_t data1;
83 jtag_callback_data_t data2;
84 jtag_callback_data_t data3;
85 };
86
87
88 static struct jtag_callback_entry *jtag_callback_queue_head = NULL;
89 static struct jtag_callback_entry *jtag_callback_queue_tail = NULL;
90 #endif
91
92
93 jtag_command_t *jtag_command_queue = NULL;
94 static jtag_command_t **next_command_pointer = &jtag_command_queue;
95 static jtag_tap_t *jtag_all_taps = NULL;
96
97 enum reset_types jtag_reset_config = RESET_NONE;
98 tap_state_t cmd_queue_end_state = TAP_RESET;
99 tap_state_t cmd_queue_cur_state = TAP_RESET;
100
101 int jtag_verify_capture_ir = 1;
102 int jtag_verify = 1;
103
104 /* how long the OpenOCD should wait before attempting JTAG communication after reset lines deasserted (in ms) */
105 static int jtag_nsrst_delay = 0; /* default to no nSRST delay */
106 static int jtag_ntrst_delay = 0; /* default to no nTRST delay */
107
108 /* maximum number of JTAG devices expected in the chain
109 */
110 #define JTAG_MAX_CHAIN_SIZE 20
111
112 /* callbacks to inform high-level handlers about JTAG state changes */
113 jtag_event_callback_t *jtag_event_callbacks;
114
115 /* speed in kHz*/
116 static int speed_khz = 0;
117 /* flag if the kHz speed was defined */
118 static int hasKHz = 0;
119
120 /* jtag interfaces (parport, FTDI-USB, TI-USB, ...)
121 */
122
123 #if BUILD_ECOSBOARD == 1
124 extern jtag_interface_t zy1000_interface;
125 #endif
126
127 #if BUILD_PARPORT == 1
128 extern jtag_interface_t parport_interface;
129 #endif
130
131 #if BUILD_DUMMY == 1
132 extern jtag_interface_t dummy_interface;
133 #endif
134
135 #if BUILD_FT2232_FTD2XX == 1
136 extern jtag_interface_t ft2232_interface;
137 #endif
138
139 #if BUILD_FT2232_LIBFTDI == 1
140 extern jtag_interface_t ft2232_interface;
141 #endif
142
143 #if BUILD_AMTJTAGACCEL == 1
144 extern jtag_interface_t amt_jtagaccel_interface;
145 #endif
146
147 #if BUILD_EP93XX == 1
148 extern jtag_interface_t ep93xx_interface;
149 #endif
150
151 #if BUILD_AT91RM9200 == 1
152 extern jtag_interface_t at91rm9200_interface;
153 #endif
154
155 #if BUILD_GW16012 == 1
156 extern jtag_interface_t gw16012_interface;
157 #endif
158
159 #if BUILD_PRESTO_LIBFTDI == 1 || BUILD_PRESTO_FTD2XX == 1
160 extern jtag_interface_t presto_interface;
161 #endif
162
163 #if BUILD_USBPROG == 1
164 extern jtag_interface_t usbprog_interface;
165 #endif
166
167 #if BUILD_JLINK == 1
168 extern jtag_interface_t jlink_interface;
169 #endif
170
171 #if BUILD_VSLLINK == 1
172 extern jtag_interface_t vsllink_interface;
173 #endif
174
175 #if BUILD_RLINK == 1
176 extern jtag_interface_t rlink_interface;
177 #endif
178
179 #if BUILD_ARMJTAGEW == 1
180 extern jtag_interface_t armjtagew_interface;
181 #endif
182
183 jtag_interface_t *jtag_interfaces[] = {
184 #if BUILD_ECOSBOARD == 1
185 &zy1000_interface,
186 #endif
187 #if BUILD_PARPORT == 1
188 &parport_interface,
189 #endif
190 #if BUILD_DUMMY == 1
191 &dummy_interface,
192 #endif
193 #if BUILD_FT2232_FTD2XX == 1
194 &ft2232_interface,
195 #endif
196 #if BUILD_FT2232_LIBFTDI == 1
197 &ft2232_interface,
198 #endif
199 #if BUILD_AMTJTAGACCEL == 1
200 &amt_jtagaccel_interface,
201 #endif
202 #if BUILD_EP93XX == 1
203 &ep93xx_interface,
204 #endif
205 #if BUILD_AT91RM9200 == 1
206 &at91rm9200_interface,
207 #endif
208 #if BUILD_GW16012 == 1
209 &gw16012_interface,
210 #endif
211 #if BUILD_PRESTO_LIBFTDI == 1 || BUILD_PRESTO_FTD2XX == 1
212 &presto_interface,
213 #endif
214 #if BUILD_USBPROG == 1
215 &usbprog_interface,
216 #endif
217 #if BUILD_JLINK == 1
218 &jlink_interface,
219 #endif
220 #if BUILD_VSLLINK == 1
221 &vsllink_interface,
222 #endif
223 #if BUILD_RLINK == 1
224 &rlink_interface,
225 #endif
226 #if BUILD_ARMJTAGEW == 1
227 &armjtagew_interface,
228 #endif
229 NULL,
230 };
231
232 static jtag_interface_t *jtag = NULL;
233
234 /* configuration */
235 static jtag_interface_t *jtag_interface = NULL;
236 int jtag_speed = 0;
237
238 /* forward declarations */
239 //void jtag_add_pathmove(int num_states, tap_state_t *path);
240 //void jtag_add_runtest(int num_cycles, tap_state_t endstate);
241 //void jtag_add_end_state(tap_state_t endstate);
242 //void jtag_add_sleep(u32 us);
243 //int jtag_execute_queue(void);
244 static tap_state_t tap_state_by_name(const char *name);
245
246 /* jtag commands */
247 static int handle_interface_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
248 static int handle_jtag_speed_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
249 static int handle_jtag_khz_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
250 static int handle_jtag_device_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
251 static int handle_reset_config_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
252 static int handle_jtag_nsrst_delay_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
253 static int handle_jtag_ntrst_delay_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
254
255 static int handle_scan_chain_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
256
257 static int handle_endstate_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
258 static int handle_jtag_reset_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
259 static int handle_runtest_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
260 static int handle_irscan_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
261 static int Jim_Command_drscan(Jim_Interp *interp, int argc, Jim_Obj *const *argv);
262 static int Jim_Command_flush_count(Jim_Interp *interp, int argc, Jim_Obj *const *args);
263
264 static int handle_verify_ircapture_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
265 static int handle_verify_jtag_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
266 static int handle_tms_sequence_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
267
268 jtag_tap_t *jtag_AllTaps(void)
269 {
270 return jtag_all_taps;
271 };
272
273 int jtag_NumTotalTaps(void)
274 {
275 jtag_tap_t *t;
276 int n;
277
278 n = 0;
279 t = jtag_AllTaps();
280 while(t){
281 n++;
282 t = t->next_tap;
283 }
284 return n;
285 }
286
287 int jtag_NumEnabledTaps(void)
288 {
289 jtag_tap_t *t;
290 int n;
291
292 n = 0;
293 t = jtag_AllTaps();
294 while(t){
295 if( t->enabled ){
296 n++;
297 }
298 t = t->next_tap;
299 }
300 return n;
301 }
302
303 jtag_tap_t *jtag_TapByString( const char *s )
304 {
305 jtag_tap_t *t;
306 char *cp;
307
308 t = jtag_AllTaps();
309 /* try name first */
310 while(t){
311 if( 0 == strcmp( t->dotted_name, s ) ){
312 break;
313 } else {
314 t = t->next_tap;
315 }
316 }
317 /* backup plan is by number */
318 if( t == NULL ){
319 /* ok - is "s" a number? */
320 int n;
321 n = strtol( s, &cp, 0 );
322 if( (s != cp) && (*cp == 0) ){
323 /* Then it is... */
324 t = jtag_TapByAbsPosition(n);
325 }
326 }
327 return t;
328 }
329
330 jtag_tap_t * jtag_TapByJimObj( Jim_Interp *interp, Jim_Obj *o )
331 {
332 jtag_tap_t *t;
333 const char *cp;
334
335 cp = Jim_GetString( o, NULL );
336 if(cp == NULL){
337 cp = "(unknown)";
338 t = NULL;
339 } else {
340 t = jtag_TapByString( cp );
341 }
342 if( t == NULL ){
343 Jim_SetResult_sprintf(interp,"Tap: %s is unknown", cp );
344 }
345 return t;
346 }
347
348 /* returns a pointer to the n-th device in the scan chain */
349 jtag_tap_t * jtag_TapByAbsPosition( int n )
350 {
351 int orig_n;
352 jtag_tap_t *t;
353
354 orig_n = n;
355 t = jtag_AllTaps();
356
357 while( t && (n > 0)) {
358 n--;
359 t = t->next_tap;
360 }
361 return t;
362 }
363
364 int jtag_register_event_callback(int (*callback)(enum jtag_event event, void *priv), void *priv)
365 {
366 jtag_event_callback_t **callbacks_p = &jtag_event_callbacks;
367
368 if (callback == NULL)
369 {
370 return ERROR_INVALID_ARGUMENTS;
371 }
372
373 if (*callbacks_p)
374 {
375 while ((*callbacks_p)->next)
376 callbacks_p = &((*callbacks_p)->next);
377 callbacks_p = &((*callbacks_p)->next);
378 }
379
380 (*callbacks_p) = malloc(sizeof(jtag_event_callback_t));
381 (*callbacks_p)->callback = callback;
382 (*callbacks_p)->priv = priv;
383 (*callbacks_p)->next = NULL;
384
385 return ERROR_OK;
386 }
387
388 int jtag_unregister_event_callback(int (*callback)(enum jtag_event event, void *priv))
389 {
390 jtag_event_callback_t **callbacks_p = &jtag_event_callbacks;
391
392 if (callback == NULL)
393 {
394 return ERROR_INVALID_ARGUMENTS;
395 }
396
397 while (*callbacks_p)
398 {
399 jtag_event_callback_t **next = &((*callbacks_p)->next);
400 if ((*callbacks_p)->callback == callback)
401 {
402 free(*callbacks_p);
403 *callbacks_p = *next;
404 }
405 callbacks_p = next;
406 }
407
408 return ERROR_OK;
409 }
410
411 int jtag_call_event_callbacks(enum jtag_event event)
412 {
413 jtag_event_callback_t *callback = jtag_event_callbacks;
414
415 LOG_DEBUG("jtag event: %s", jtag_event_strings[event]);
416
417 while (callback)
418 {
419 callback->callback(event, callback->priv);
420 callback = callback->next;
421 }
422
423 return ERROR_OK;
424 }
425
426 void jtag_queue_command(jtag_command_t * cmd)
427 {
428 // this command goes on the end, so ensure the queue terminates
429 cmd->next = NULL;
430
431 jtag_command_t **last_cmd = next_command_pointer;
432 assert(NULL != last_cmd);
433 assert(NULL == *last_cmd);
434 *last_cmd = cmd;
435
436 // store location where the next command pointer will be stored
437 next_command_pointer = &cmd->next;
438 }
439
440 void* cmd_queue_alloc(size_t size)
441 {
442 cmd_queue_page_t **p_page = &cmd_queue_pages;
443 int offset;
444 u8 *t;
445
446 /*
447 * WARNING:
448 * We align/round the *SIZE* per below
449 * so that all pointers returned by
450 * this function are reasonably well
451 * aligned.
452 *
453 * If we did not, then an "odd-length" request would cause the
454 * *next* allocation to be at an *odd* address, and because
455 * this function has the same type of api as malloc() - we
456 * must also return pointers that have the same type of
457 * alignment.
458 *
459 * What I do not/have is a reasonable portable means
460 * to align by...
461 *
462 * The solution here, is based on these suggestions.
463 * http://gcc.gnu.org/ml/gcc-help/2008-12/msg00041.html
464 *
465 */
466 union worse_case_align {
467 int i;
468 long l;
469 float f;
470 void *v;
471 };
472 #define ALIGN_SIZE (sizeof(union worse_case_align))
473
474 /* The alignment process. */
475 size = (size + ALIGN_SIZE -1) & (~(ALIGN_SIZE-1));
476 /* Done... */
477
478 if (*p_page)
479 {
480 while ((*p_page)->next)
481 p_page = &((*p_page)->next);
482 if (CMD_QUEUE_PAGE_SIZE - (*p_page)->used < size)
483 p_page = &((*p_page)->next);
484 }
485
486 if (!*p_page)
487 {
488 *p_page = malloc(sizeof(cmd_queue_page_t));
489 (*p_page)->used = 0;
490 (*p_page)->address = malloc(CMD_QUEUE_PAGE_SIZE);
491 (*p_page)->next = NULL;
492 }
493
494 offset = (*p_page)->used;
495 (*p_page)->used += size;
496
497 t=(u8 *)((*p_page)->address);
498 return t + offset;
499 }
500
501 void cmd_queue_free(void)
502 {
503 cmd_queue_page_t *page = cmd_queue_pages;
504
505 while (page)
506 {
507 cmd_queue_page_t *last = page;
508 free(page->address);
509 page = page->next;
510 free(last);
511 }
512
513 cmd_queue_pages = NULL;
514 }
515
516 void jtag_command_queue_reset(void)
517 {
518 cmd_queue_free();
519
520 jtag_command_queue = NULL;
521 next_command_pointer = &jtag_command_queue;
522 }
523
524 /**
525 * Copy a scan_field_t for insertion into the queue.
526 *
527 * This allocates a new copy of out_value using cmd_queue_alloc.
528 */
529 static void cmd_queue_scan_field_clone(scan_field_t * dst, const scan_field_t * src)
530 {
531 dst->tap = src->tap;
532 dst->num_bits = src->num_bits;
533 dst->out_value = buf_cpy(src->out_value, cmd_queue_alloc(CEIL(src->num_bits, 8)), src->num_bits);
534 dst->in_value = src->in_value;
535 }
536
537
538 static void jtag_prelude1(void)
539 {
540 if (jtag_trst == 1)
541 {
542 LOG_WARNING("JTAG command queued, while TRST is low (TAP in reset)");
543 jtag_error=ERROR_JTAG_TRST_ASSERTED;
544 return;
545 }
546
547 if (cmd_queue_end_state == TAP_RESET)
548 jtag_call_event_callbacks(JTAG_TRST_ASSERTED);
549 }
550
551 static void jtag_prelude(tap_state_t state)
552 {
553 jtag_prelude1();
554
555 if (state != TAP_INVALID)
556 jtag_add_end_state(state);
557
558 cmd_queue_cur_state = cmd_queue_end_state;
559 }
560
561 void jtag_add_ir_scan_noverify(int in_num_fields, const scan_field_t *in_fields, tap_state_t state)
562 {
563 int retval;
564 jtag_prelude(state);
565
566 retval=interface_jtag_add_ir_scan(in_num_fields, in_fields, cmd_queue_end_state);
567 if (retval!=ERROR_OK)
568 jtag_error=retval;
569
570 }
571
572
573 /**
574 * Generate an IR SCAN with a list of scan fields with one entry for each enabled TAP.
575 *
576 * If the input field list contains an instruction value for a TAP then that is used
577 * otherwise the TAP is set to bypass.
578 *
579 * TAPs for which no fields are passed are marked as bypassed for subsequent DR SCANs.
580 *
581 */
582 void jtag_add_ir_scan(int in_num_fields, scan_field_t *in_fields, tap_state_t state)
583 {
584 if (jtag_verify&&jtag_verify_capture_ir)
585 {
586 /* 8 x 32 bit id's is enough for all invocations */
587
588 for (int j = 0; j < in_num_fields; j++)
589 {
590 /* if we are to run a verification of the ir scan, we need to get the input back.
591 * We may have to allocate space if the caller didn't ask for the input back.
592 */
593 in_fields[j].check_value=in_fields[j].tap->expected;
594 in_fields[j].check_mask=in_fields[j].tap->expected_mask;
595 }
596 jtag_add_scan_check(jtag_add_ir_scan_noverify, in_num_fields, in_fields, state);
597 } else
598 {
599 jtag_add_ir_scan_noverify(in_num_fields, in_fields, state);
600 }
601 }
602
603 /**
604 * see jtag_add_ir_scan()
605 *
606 */
607 int MINIDRIVER(interface_jtag_add_ir_scan)(int in_num_fields, const scan_field_t *in_fields, tap_state_t state)
608 {
609 size_t num_taps = jtag_NumEnabledTaps();
610
611 jtag_command_t * cmd = cmd_queue_alloc(sizeof(jtag_command_t));
612 scan_command_t * scan = cmd_queue_alloc(sizeof(scan_command_t));
613 scan_field_t * out_fields = cmd_queue_alloc(num_taps * sizeof(scan_field_t));
614
615 jtag_queue_command(cmd);
616
617 cmd->type = JTAG_SCAN;
618 cmd->cmd.scan = scan;
619
620 scan->ir_scan = true;
621 scan->num_fields = num_taps; /* one field per device */
622 scan->fields = out_fields;
623 scan->end_state = state;
624
625
626 scan_field_t * field = out_fields; /* keep track where we insert data */
627
628 /* loop over all enabled TAPs */
629
630 for (jtag_tap_t * tap = jtag_NextEnabledTap(NULL); tap != NULL; tap = jtag_NextEnabledTap(tap))
631 {
632 /* search the input field list for fields for the current TAP */
633
634 bool found = false;
635
636 for (int j = 0; j < in_num_fields; j++)
637 {
638 if (tap != in_fields[j].tap)
639 continue;
640
641 /* if TAP is listed in input fields, copy the value */
642
643 found = true;
644
645 tap->bypass = 0;
646
647 assert(in_fields[j].num_bits == tap->ir_length); /* input fields must have the same length as the TAP's IR */
648
649 cmd_queue_scan_field_clone(field, in_fields + j);
650
651 break;
652 }
653
654 if (!found)
655 {
656 /* if a TAP isn't listed in input fields, set it to BYPASS */
657
658 tap->bypass = 1;
659
660 field->tap = tap;
661 field->num_bits = tap->ir_length;
662 field->out_value = buf_set_ones(cmd_queue_alloc(CEIL(tap->ir_length, 8)), tap->ir_length);
663 field->in_value = NULL; /* do not collect input for tap's in bypass */
664 }
665
666 /* update device information */
667 buf_cpy(field->out_value, tap->cur_instr, tap->ir_length);
668
669 field++;
670 }
671
672 assert(field == out_fields + num_taps); /* paranoia: jtag_NumEnabledTaps() and jtag_NextEnabledTap() not in sync */
673
674 return ERROR_OK;
675 }
676
677 /**
678 * Duplicate the scan fields passed into the function into an IR SCAN command
679 *
680 * This function assumes that the caller handles extra fields for bypassed TAPs
681 *
682 */
683 void jtag_add_plain_ir_scan(int in_num_fields, const scan_field_t *in_fields, tap_state_t state)
684 {
685 int retval;
686
687 jtag_prelude(state);
688
689 retval=interface_jtag_add_plain_ir_scan(in_num_fields, in_fields, cmd_queue_end_state);
690 if (retval!=ERROR_OK)
691 jtag_error=retval;
692 }
693
694
695 /**
696 * see jtag_add_plain_ir_scan()
697 *
698 */
699 int MINIDRIVER(interface_jtag_add_plain_ir_scan)(int in_num_fields, const scan_field_t *in_fields, tap_state_t state)
700 {
701
702 jtag_command_t * cmd = cmd_queue_alloc(sizeof(jtag_command_t));
703 scan_command_t * scan = cmd_queue_alloc(sizeof(scan_command_t));
704 scan_field_t * out_fields = cmd_queue_alloc(in_num_fields * sizeof(scan_field_t));
705
706 jtag_queue_command(cmd);
707
708 cmd->type = JTAG_SCAN;
709 cmd->cmd.scan = scan;
710
711 scan->ir_scan = true;
712 scan->num_fields = in_num_fields;
713 scan->fields = out_fields;
714 scan->end_state = state;
715
716 for (int i = 0; i < in_num_fields; i++)
717 cmd_queue_scan_field_clone(out_fields + i, in_fields + i);
718
719 return ERROR_OK;
720 }
721
722
723
724 int jtag_check_value_inner(u8 *captured, u8 *in_check_value, u8 *in_check_mask, int num_bits);
725
726 static int jtag_check_value_mask_callback(u8 *in, jtag_callback_data_t data1, jtag_callback_data_t data2, jtag_callback_data_t data3)
727 {
728 return jtag_check_value_inner(in, (u8 *)data1, (u8 *)data2, (int)data3);
729 }
730
731 #ifdef HAVE_JTAG_MINIDRIVER_H
732 void interface_jtag_add_scan_check_alloc(scan_field_t *field)
733 {
734 /* We're executing this synchronously, so try to use local storage. */
735 if (field->num_bits > 32)
736 {
737 unsigned num_bytes = TAP_SCAN_BYTES(field->num_bits);
738 field->in_value = (u8 *)malloc(num_bytes);
739 field->allocated = 1;
740 }
741 else
742 field->in_value = field->intmp;
743 }
744 #else
745 void interface_jtag_add_scan_check_alloc(scan_field_t *field)
746 {
747 unsigned num_bytes = TAP_SCAN_BYTES(field->num_bits);
748 field->in_value = (u8 *)cmd_queue_alloc(num_bytes);
749 }
750 #endif
751
752 static void jtag_add_scan_check(void (*jtag_add_scan)(int in_num_fields, const scan_field_t *in_fields, tap_state_t state),
753 int in_num_fields, scan_field_t *in_fields, tap_state_t state)
754 {
755 for (int i = 0; i < in_num_fields; i++)
756 {
757 struct scan_field_s *field = &in_fields[i];
758 field->allocated = 0;
759 field->modified = 0;
760 if (field->check_value || field->in_value)
761 continue;
762 interface_jtag_add_scan_check_alloc(field);
763 field->modified = 1;
764 }
765
766 jtag_add_scan(in_num_fields, in_fields, state);
767
768 for (int i = 0; i < in_num_fields; i++)
769 {
770 if ((in_fields[i].check_value != NULL) && (in_fields[i].in_value != NULL))
771 {
772 /* this is synchronous for a minidriver */
773 jtag_add_callback4(jtag_check_value_mask_callback, in_fields[i].in_value,
774 (jtag_callback_data_t)in_fields[i].check_value,
775 (jtag_callback_data_t)in_fields[i].check_mask,
776 (jtag_callback_data_t)in_fields[i].num_bits);
777 }
778 if (in_fields[i].allocated)
779 {
780 free(in_fields[i].in_value);
781 }
782 if (in_fields[i].modified)
783 {
784 in_fields[i].in_value = NULL;
785 }
786 }
787 }
788
789 void jtag_add_dr_scan_check(int in_num_fields, scan_field_t *in_fields, tap_state_t state)
790 {
791 if (jtag_verify)
792 {
793 jtag_add_scan_check(jtag_add_dr_scan, in_num_fields, in_fields, state);
794 } else
795 {
796 jtag_add_dr_scan(in_num_fields, in_fields, state);
797 }
798 }
799
800
801 /**
802 * Generate a DR SCAN using the fields passed to the function
803 *
804 * For not bypassed TAPs the function checks in_fields and uses fields specified there.
805 * For bypassed TAPs the function generates a dummy 1bit field.
806 *
807 * The bypass status of TAPs is set by jtag_add_ir_scan().
808 *
809 */
810 void jtag_add_dr_scan(int in_num_fields, const scan_field_t *in_fields, tap_state_t state)
811 {
812 int retval;
813
814 jtag_prelude(state);
815
816 retval=interface_jtag_add_dr_scan(in_num_fields, in_fields, cmd_queue_end_state);
817 if (retval!=ERROR_OK)
818 jtag_error=retval;
819 }
820
821
822 /**
823 * see jtag_add_dr_scan()
824 *
825 */
826 int MINIDRIVER(interface_jtag_add_dr_scan)(int in_num_fields, const scan_field_t *in_fields, tap_state_t state)
827 {
828 /* count devices in bypass */
829
830 size_t bypass_devices = 0;
831
832 for (jtag_tap_t * tap = jtag_NextEnabledTap(NULL); tap != NULL; tap = jtag_NextEnabledTap(tap))
833 {
834 if (tap->bypass)
835 bypass_devices++;
836 }
837
838 jtag_command_t * cmd = cmd_queue_alloc(sizeof(jtag_command_t));
839 scan_command_t * scan = cmd_queue_alloc(sizeof(scan_command_t));
840 scan_field_t * out_fields = cmd_queue_alloc((in_num_fields + bypass_devices) * sizeof(scan_field_t));
841
842 jtag_queue_command(cmd);
843
844 cmd->type = JTAG_SCAN;
845 cmd->cmd.scan = scan;
846
847 scan->ir_scan = false;
848 scan->num_fields = in_num_fields + bypass_devices;
849 scan->fields = out_fields;
850 scan->end_state = state;
851
852
853 scan_field_t * field = out_fields; /* keep track where we insert data */
854
855 /* loop over all enabled TAPs */
856
857 for (jtag_tap_t * tap = jtag_NextEnabledTap(NULL); tap != NULL; tap = jtag_NextEnabledTap(tap))
858 {
859 /* if TAP is not bypassed insert matching input fields */
860
861 if (!tap->bypass)
862 {
863 scan_field_t * start_field = field; /* keep initial position for assert() */
864
865 for (int j = 0; j < in_num_fields; j++)
866 {
867 if (tap != in_fields[j].tap)
868 continue;
869
870 cmd_queue_scan_field_clone(field, in_fields + j);
871
872 field++;
873 }
874
875 assert(field > start_field); /* must have at least one input field per not bypassed TAP */
876 }
877
878 /* if a TAP is bypassed, generated a dummy bit*/
879 else
880 {
881 field->tap = tap;
882 field->num_bits = 1;
883 field->out_value = NULL;
884 field->in_value = NULL;
885
886 field++;
887 }
888 }
889
890 assert(field == out_fields + scan->num_fields); /* no superfluous input fields permitted */
891
892 return ERROR_OK;
893 }
894
895
896
897 /**
898 * Generate a DR SCAN using the array of output values passed to the function
899 *
900 * This function assumes that the parameter target_tap specifies the one TAP
901 * that is not bypassed. All other TAPs must be bypassed and the function will
902 * generate a dummy 1bit field for them.
903 *
904 * For the target_tap a sequence of output-only fields will be generated where
905 * each field has the size num_bits and the field's values are taken from
906 * the array value.
907 *
908 * The bypass status of TAPs is set by jtag_add_ir_scan().
909 *
910 */
911 void MINIDRIVER(interface_jtag_add_dr_out)(jtag_tap_t *target_tap,
912 int in_num_fields,
913 const int *num_bits,
914 const u32 *value,
915 tap_state_t end_state)
916 {
917 /* count devices in bypass */
918
919 size_t bypass_devices = 0;
920
921 for (jtag_tap_t * tap = jtag_NextEnabledTap(NULL); tap != NULL; tap = jtag_NextEnabledTap(tap))
922 {
923 if (tap->bypass)
924 bypass_devices++;
925 }
926
927
928 jtag_command_t * cmd = cmd_queue_alloc(sizeof(jtag_command_t));
929 scan_command_t * scan = cmd_queue_alloc(sizeof(scan_command_t));
930 scan_field_t * out_fields = cmd_queue_alloc((in_num_fields + bypass_devices) * sizeof(scan_field_t));
931
932 jtag_queue_command(cmd);
933
934 cmd->type = JTAG_SCAN;
935 cmd->cmd.scan = scan;
936
937 scan->ir_scan = false;
938 scan->num_fields = in_num_fields + bypass_devices;
939 scan->fields = out_fields;
940 scan->end_state = end_state;
941
942
943 bool target_tap_match = false;
944
945 scan_field_t * field = out_fields; /* keep track where we insert data */
946
947 /* loop over all enabled TAPs */
948
949 for (jtag_tap_t * tap = jtag_NextEnabledTap(NULL); tap != NULL; tap = jtag_NextEnabledTap(tap))
950 {
951 /* if TAP is not bypassed insert matching input fields */
952
953 if (!tap->bypass)
954 {
955 assert(tap == target_tap); /* target_tap must match the one not bypassed TAP */
956
957 target_tap_match = true;
958
959 for (int j = 0; j < in_num_fields; j++)
960 {
961 u8 out_value[4];
962 size_t scan_size = num_bits[j];
963 buf_set_u32(out_value, 0, scan_size, value[j]);
964
965 field->tap = tap;
966 field->num_bits = scan_size;
967 field->out_value = buf_cpy(out_value, cmd_queue_alloc(CEIL(scan_size, 8)), scan_size);
968 field->in_value = NULL;
969
970 field++;
971 }
972 }
973
974 /* if a TAP is bypassed, generated a dummy bit*/
975 else
976 {
977
978 field->tap = tap;
979 field->num_bits = 1;
980 field->out_value = NULL;
981 field->in_value = NULL;
982
983 field++;
984 }
985 }
986
987 assert(target_tap_match); /* target_tap should be enabled and not bypassed */
988 }
989
990
991 /**
992 * Duplicate the scan fields passed into the function into a DR SCAN command
993 *
994 * This function assumes that the caller handles extra fields for bypassed TAPs
995 *
996 */
997 void jtag_add_plain_dr_scan(int in_num_fields, const scan_field_t *in_fields, tap_state_t state)
998 {
999 int retval;
1000
1001 jtag_prelude(state);
1002
1003 retval=interface_jtag_add_plain_dr_scan(in_num_fields, in_fields, cmd_queue_end_state);
1004 if (retval!=ERROR_OK)
1005 jtag_error=retval;
1006 }
1007
1008
1009 /**
1010 * see jtag_add_plain_dr_scan()
1011 *
1012 */
1013 int MINIDRIVER(interface_jtag_add_plain_dr_scan)(int in_num_fields, const scan_field_t *in_fields, tap_state_t state)
1014 {
1015 jtag_command_t * cmd = cmd_queue_alloc(sizeof(jtag_command_t));
1016 scan_command_t * scan = cmd_queue_alloc(sizeof(scan_command_t));
1017 scan_field_t * out_fields = cmd_queue_alloc(in_num_fields * sizeof(scan_field_t));
1018
1019 jtag_queue_command(cmd);
1020
1021 cmd->type = JTAG_SCAN;
1022 cmd->cmd.scan = scan;
1023
1024 scan->ir_scan = false;
1025 scan->num_fields = in_num_fields;
1026 scan->fields = out_fields;
1027 scan->end_state = state;
1028
1029 for (int i = 0; i < in_num_fields; i++)
1030 cmd_queue_scan_field_clone(out_fields + i, in_fields + i);
1031
1032 return ERROR_OK;
1033 }
1034
1035
1036 void jtag_add_tlr(void)
1037 {
1038 jtag_prelude(TAP_RESET);
1039
1040 int retval;
1041 retval=interface_jtag_add_tlr();
1042 if (retval!=ERROR_OK)
1043 jtag_error=retval;
1044 }
1045
1046 int MINIDRIVER(interface_jtag_add_tlr)(void)
1047 {
1048 tap_state_t state = TAP_RESET;
1049
1050 /* allocate memory for a new list member */
1051 jtag_command_t * cmd = cmd_queue_alloc(sizeof(jtag_command_t));
1052
1053 jtag_queue_command(cmd);
1054
1055 cmd->type = JTAG_STATEMOVE;
1056
1057 cmd->cmd.statemove = cmd_queue_alloc(sizeof(statemove_command_t));
1058 cmd->cmd.statemove->end_state = state;
1059
1060 return ERROR_OK;
1061 }
1062
1063 void jtag_add_pathmove(int num_states, const tap_state_t *path)
1064 {
1065 tap_state_t cur_state = cmd_queue_cur_state;
1066 int i;
1067 int retval;
1068
1069 /* the last state has to be a stable state */
1070 if (!tap_is_state_stable(path[num_states - 1]))
1071 {
1072 LOG_ERROR("BUG: TAP path doesn't finish in a stable state");
1073 exit(-1);
1074 }
1075
1076 for (i=0; i<num_states; i++)
1077 {
1078 if (path[i] == TAP_RESET)
1079 {
1080 LOG_ERROR("BUG: TAP_RESET is not a valid state for pathmove sequences");
1081 exit(-1);
1082 }
1083
1084 if ( tap_state_transition(cur_state, true) != path[i]
1085 && tap_state_transition(cur_state, false) != path[i])
1086 {
1087 LOG_ERROR("BUG: %s -> %s isn't a valid TAP transition", tap_state_name(cur_state), tap_state_name(path[i]));
1088 exit(-1);
1089 }
1090 cur_state = path[i];
1091 }
1092
1093 jtag_prelude1();
1094
1095 retval = interface_jtag_add_pathmove(num_states, path);
1096 cmd_queue_cur_state = path[num_states - 1];
1097 if (retval!=ERROR_OK)
1098 jtag_error=retval;
1099 }
1100
1101 int MINIDRIVER(interface_jtag_add_pathmove)(int num_states, const tap_state_t *path)
1102 {
1103 /* allocate memory for a new list member */
1104 jtag_command_t * cmd = cmd_queue_alloc(sizeof(jtag_command_t));
1105
1106 jtag_queue_command(cmd);
1107
1108 cmd->type = JTAG_PATHMOVE;
1109
1110 cmd->cmd.pathmove = cmd_queue_alloc(sizeof(pathmove_command_t));
1111 cmd->cmd.pathmove->num_states = num_states;
1112 cmd->cmd.pathmove->path = cmd_queue_alloc(sizeof(tap_state_t) * num_states);
1113
1114 for (int i = 0; i < num_states; i++)
1115 cmd->cmd.pathmove->path[i] = path[i];
1116
1117 return ERROR_OK;
1118 }
1119
1120 int MINIDRIVER(interface_jtag_add_runtest)(int num_cycles, tap_state_t state)
1121 {
1122 /* allocate memory for a new list member */
1123 jtag_command_t * cmd = cmd_queue_alloc(sizeof(jtag_command_t));
1124
1125 jtag_queue_command(cmd);
1126
1127 cmd->type = JTAG_RUNTEST;
1128
1129 cmd->cmd.runtest = cmd_queue_alloc(sizeof(runtest_command_t));
1130 cmd->cmd.runtest->num_cycles = num_cycles;
1131 cmd->cmd.runtest->end_state = state;
1132
1133 return ERROR_OK;
1134 }
1135
1136 void jtag_add_runtest(int num_cycles, tap_state_t state)
1137 {
1138 int retval;
1139
1140 jtag_prelude(state);
1141
1142 /* executed by sw or hw fifo */
1143 retval=interface_jtag_add_runtest(num_cycles, cmd_queue_end_state);
1144 if (retval!=ERROR_OK)
1145 jtag_error=retval;
1146 }
1147
1148
1149 int MINIDRIVER(interface_jtag_add_clocks)( int num_cycles )
1150 {
1151 /* allocate memory for a new list member */
1152 jtag_command_t * cmd = cmd_queue_alloc(sizeof(jtag_command_t));
1153
1154 jtag_queue_command(cmd);
1155
1156 cmd->type = JTAG_STABLECLOCKS;
1157
1158 cmd->cmd.stableclocks = cmd_queue_alloc(sizeof(stableclocks_command_t));
1159 cmd->cmd.stableclocks->num_cycles = num_cycles;
1160
1161 return ERROR_OK;
1162 }
1163
1164 void jtag_add_clocks( int num_cycles )
1165 {
1166 int retval;
1167
1168 if( !tap_is_state_stable(cmd_queue_cur_state) )
1169 {
1170 LOG_ERROR( "jtag_add_clocks() was called with TAP in non-stable state \"%s\"",
1171 tap_state_name(cmd_queue_cur_state) );
1172 jtag_error = ERROR_JTAG_NOT_STABLE_STATE;
1173 return;
1174 }
1175
1176 if( num_cycles > 0 )
1177 {
1178 jtag_prelude1();
1179
1180 retval = interface_jtag_add_clocks(num_cycles);
1181 if (retval != ERROR_OK)
1182 jtag_error=retval;
1183 }
1184 }
1185
1186 void jtag_add_reset(int req_tlr_or_trst, int req_srst)
1187 {
1188 int trst_with_tlr = 0;
1189 int retval;
1190
1191 /* FIX!!! there are *many* different cases here. A better
1192 * approach is needed for legal combinations of transitions...
1193 */
1194 if ((jtag_reset_config & RESET_HAS_SRST)&&
1195 (jtag_reset_config & RESET_HAS_TRST)&&
1196 ((jtag_reset_config & RESET_SRST_PULLS_TRST)==0))
1197 {
1198 if (((req_tlr_or_trst&&!jtag_trst)||
1199 (!req_tlr_or_trst&&jtag_trst))&&
1200 ((req_srst&&!jtag_srst)||
1201 (!req_srst&&jtag_srst)))
1202 {
1203 /* FIX!!! srst_pulls_trst allows 1,1 => 0,0 transition.... */
1204 //LOG_ERROR("BUG: transition of req_tlr_or_trst and req_srst in the same jtag_add_reset() call is undefined");
1205 }
1206 }
1207
1208 /* Make sure that jtag_reset_config allows the requested reset */
1209 /* if SRST pulls TRST, we can't fulfill srst == 1 with trst == 0 */
1210 if (((jtag_reset_config & RESET_SRST_PULLS_TRST) && (req_srst == 1)) && (!req_tlr_or_trst))
1211 {
1212 LOG_ERROR("BUG: requested reset would assert trst");
1213 jtag_error=ERROR_FAIL;
1214 return;
1215 }
1216
1217 /* if TRST pulls SRST, we reset with TAP T-L-R */
1218 if (((jtag_reset_config & RESET_TRST_PULLS_SRST) && (req_tlr_or_trst)) && (req_srst == 0))
1219 {
1220 trst_with_tlr = 1;
1221 }
1222
1223 if (req_srst && !(jtag_reset_config & RESET_HAS_SRST))
1224 {
1225 LOG_ERROR("BUG: requested SRST assertion, but the current configuration doesn't support this");
1226 jtag_error=ERROR_FAIL;
1227 return;
1228 }
1229
1230 if (req_tlr_or_trst)
1231 {
1232 if (!trst_with_tlr && (jtag_reset_config & RESET_HAS_TRST))
1233 {
1234 jtag_trst = 1;
1235 } else
1236 {
1237 trst_with_tlr = 1;
1238 }
1239 } else
1240 {
1241 jtag_trst = 0;
1242 }
1243
1244 jtag_srst = req_srst;
1245
1246 retval = interface_jtag_add_reset(jtag_trst, jtag_srst);
1247 if (retval!=ERROR_OK)
1248 {
1249 jtag_error=retval;
1250 return;
1251 }
1252 jtag_execute_queue();
1253
1254 if (jtag_srst)
1255 {
1256 LOG_DEBUG("SRST line asserted");
1257 }
1258 else
1259 {
1260 LOG_DEBUG("SRST line released");
1261 if (jtag_nsrst_delay)
1262 jtag_add_sleep(jtag_nsrst_delay * 1000);
1263 }
1264
1265 if (trst_with_tlr)
1266 {
1267 LOG_DEBUG("JTAG reset with RESET instead of TRST");
1268 jtag_add_end_state(TAP_RESET);
1269 jtag_add_tlr();
1270 jtag_call_event_callbacks(JTAG_TRST_ASSERTED);
1271 return;
1272 }
1273
1274 if (jtag_trst)
1275 {
1276 /* we just asserted nTRST, so we're now in Test-Logic-Reset,
1277 * and inform possible listeners about this
1278 */
1279 LOG_DEBUG("TRST line asserted");
1280 tap_set_state(TAP_RESET);
1281 jtag_call_event_callbacks(JTAG_TRST_ASSERTED);
1282 }
1283 else
1284 {
1285 if (jtag_ntrst_delay)
1286 jtag_add_sleep(jtag_ntrst_delay * 1000);
1287 }
1288 }
1289
1290 int MINIDRIVER(interface_jtag_add_reset)(int req_trst, int req_srst)
1291 {
1292 /* allocate memory for a new list member */
1293 jtag_command_t * cmd = cmd_queue_alloc(sizeof(jtag_command_t));
1294
1295 jtag_queue_command(cmd);
1296
1297 cmd->type = JTAG_RESET;
1298
1299 cmd->cmd.reset = cmd_queue_alloc(sizeof(reset_command_t));
1300 cmd->cmd.reset->trst = req_trst;
1301 cmd->cmd.reset->srst = req_srst;
1302
1303 return ERROR_OK;
1304 }
1305
1306 void jtag_add_end_state(tap_state_t state)
1307 {
1308 cmd_queue_end_state = state;
1309 if ((cmd_queue_end_state == TAP_DRSHIFT)||(cmd_queue_end_state == TAP_IRSHIFT))
1310 {
1311 LOG_ERROR("BUG: TAP_DRSHIFT/IRSHIFT can't be end state. Calling code should use a larger scan field");
1312 }
1313 }
1314
1315 int MINIDRIVER(interface_jtag_add_sleep)(u32 us)
1316 {
1317 /* allocate memory for a new list member */
1318 jtag_command_t * cmd = cmd_queue_alloc(sizeof(jtag_command_t));
1319
1320 jtag_queue_command(cmd);
1321
1322 cmd->type = JTAG_SLEEP;
1323
1324 cmd->cmd.sleep = cmd_queue_alloc(sizeof(sleep_command_t));
1325 cmd->cmd.sleep->us = us;
1326
1327 return ERROR_OK;
1328 }
1329
1330 void jtag_add_sleep(u32 us)
1331 {
1332 keep_alive(); /* we might be running on a very slow JTAG clk */
1333 int retval=interface_jtag_add_sleep(us);
1334 if (retval!=ERROR_OK)
1335 jtag_error=retval;
1336 return;
1337 }
1338
1339 int jtag_scan_size(const scan_command_t *cmd)
1340 {
1341 int bit_count = 0;
1342 int i;
1343
1344 /* count bits in scan command */
1345 for (i = 0; i < cmd->num_fields; i++)
1346 {
1347 bit_count += cmd->fields[i].num_bits;
1348 }
1349
1350 return bit_count;
1351 }
1352
1353 int jtag_build_buffer(const scan_command_t *cmd, u8 **buffer)
1354 {
1355 int bit_count = 0;
1356 int i;
1357
1358 bit_count = jtag_scan_size(cmd);
1359 *buffer = calloc(1,CEIL(bit_count, 8));
1360
1361 bit_count = 0;
1362
1363 #ifdef _DEBUG_JTAG_IO_
1364 LOG_DEBUG("%s num_fields: %i", cmd->ir_scan ? "IRSCAN" : "DRSCAN", cmd->num_fields);
1365 #endif
1366
1367 for (i = 0; i < cmd->num_fields; i++)
1368 {
1369 if (cmd->fields[i].out_value)
1370 {
1371 #ifdef _DEBUG_JTAG_IO_
1372 char* char_buf = buf_to_str(cmd->fields[i].out_value, (cmd->fields[i].num_bits > DEBUG_JTAG_IOZ) ? DEBUG_JTAG_IOZ : cmd->fields[i].num_bits, 16);
1373 #endif
1374 buf_set_buf(cmd->fields[i].out_value, 0, *buffer, bit_count, cmd->fields[i].num_bits);
1375 #ifdef _DEBUG_JTAG_IO_
1376 LOG_DEBUG("fields[%i].out_value[%i]: 0x%s", i, cmd->fields[i].num_bits, char_buf);
1377 free(char_buf);
1378 #endif
1379 }
1380 else
1381 {
1382 #ifdef _DEBUG_JTAG_IO_
1383 LOG_DEBUG("fields[%i].out_value[%i]: NULL", i, cmd->fields[i].num_bits);
1384 #endif
1385 }
1386
1387 bit_count += cmd->fields[i].num_bits;
1388 }
1389
1390 #ifdef _DEBUG_JTAG_IO_
1391 //LOG_DEBUG("bit_count totalling: %i", bit_count );
1392 #endif
1393
1394 return bit_count;
1395 }
1396
1397 int jtag_read_buffer(u8 *buffer, const scan_command_t *cmd)
1398 {
1399 int i;
1400 int bit_count = 0;
1401 int retval;
1402
1403 /* we return ERROR_OK, unless a check fails, or a handler reports a problem */
1404 retval = ERROR_OK;
1405
1406 for (i = 0; i < cmd->num_fields; i++)
1407 {
1408 /* if neither in_value nor in_handler
1409 * are specified we don't have to examine this field
1410 */
1411 if (cmd->fields[i].in_value)
1412 {
1413 int num_bits = cmd->fields[i].num_bits;
1414 u8 *captured = buf_set_buf(buffer, bit_count, malloc(CEIL(num_bits, 8)), 0, num_bits);
1415
1416 #ifdef _DEBUG_JTAG_IO_
1417 char *char_buf = buf_to_str(captured, (num_bits > DEBUG_JTAG_IOZ) ? DEBUG_JTAG_IOZ : num_bits, 16);
1418 LOG_DEBUG("fields[%i].in_value[%i]: 0x%s", i, num_bits, char_buf);
1419 free(char_buf);
1420 #endif
1421
1422 if (cmd->fields[i].in_value)
1423 {
1424 buf_cpy(captured, cmd->fields[i].in_value, num_bits);
1425 }
1426
1427 free(captured);
1428 }
1429 bit_count += cmd->fields[i].num_bits;
1430 }
1431
1432 return retval;
1433 }
1434
1435 static const char *jtag_tap_name(const jtag_tap_t *tap)
1436 {
1437 return (tap == NULL) ? "(unknown)" : tap->dotted_name;
1438 }
1439
1440 int jtag_check_value_inner(u8 *captured, u8 *in_check_value, u8 *in_check_mask, int num_bits)
1441 {
1442 int retval = ERROR_OK;
1443
1444 int compare_failed = 0;
1445
1446 if (in_check_mask)
1447 compare_failed = buf_cmp_mask(captured, in_check_value, in_check_mask, num_bits);
1448 else
1449 compare_failed = buf_cmp(captured, in_check_value, num_bits);
1450
1451 if (compare_failed){
1452 /* An error handler could have caught the failing check
1453 * only report a problem when there wasn't a handler, or if the handler
1454 * acknowledged the error
1455 */
1456 /*
1457 LOG_WARNING("TAP %s:",
1458 jtag_tap_name(field->tap));
1459 */
1460 if (compare_failed)
1461 {
1462 char *captured_char = buf_to_str(captured, (num_bits > DEBUG_JTAG_IOZ) ? DEBUG_JTAG_IOZ : num_bits, 16);
1463 char *in_check_value_char = buf_to_str(in_check_value, (num_bits > DEBUG_JTAG_IOZ) ? DEBUG_JTAG_IOZ : num_bits, 16);
1464
1465 if (in_check_mask)
1466 {
1467 char *in_check_mask_char;
1468 in_check_mask_char = buf_to_str(in_check_mask, (num_bits > DEBUG_JTAG_IOZ) ? DEBUG_JTAG_IOZ : num_bits, 16);
1469 LOG_WARNING("value captured during scan didn't pass the requested check:");
1470 LOG_WARNING("captured: 0x%s check_value: 0x%s check_mask: 0x%s",
1471 captured_char, in_check_value_char, in_check_mask_char);
1472 free(in_check_mask_char);
1473 }
1474 else
1475 {
1476 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);
1477 }
1478
1479 free(captured_char);
1480 free(in_check_value_char);
1481
1482 retval = ERROR_JTAG_QUEUE_FAILED;
1483 }
1484
1485 }
1486 return retval;
1487 }
1488
1489 void jtag_check_value_mask(scan_field_t *field, u8 *value, u8 *mask)
1490 {
1491 assert(field->in_value != NULL);
1492
1493 if (value==NULL)
1494 {
1495 /* no checking to do */
1496 return;
1497 }
1498
1499 jtag_execute_queue_noclear();
1500
1501 int retval=jtag_check_value_inner(field->in_value, value, mask, field->num_bits);
1502 jtag_set_error(retval);
1503 }
1504
1505
1506
1507 enum scan_type jtag_scan_type(const scan_command_t *cmd)
1508 {
1509 int i;
1510 int type = 0;
1511
1512 for (i = 0; i < cmd->num_fields; i++)
1513 {
1514 if (cmd->fields[i].in_value)
1515 type |= SCAN_IN;
1516 if (cmd->fields[i].out_value)
1517 type |= SCAN_OUT;
1518 }
1519
1520 return type;
1521 }
1522
1523
1524 #ifndef HAVE_JTAG_MINIDRIVER_H
1525 /* add callback to end of queue */
1526 void jtag_add_callback4(jtag_callback_t callback, u8 *in, jtag_callback_data_t data1, jtag_callback_data_t data2, jtag_callback_data_t data3)
1527 {
1528 struct jtag_callback_entry *entry=cmd_queue_alloc(sizeof(struct jtag_callback_entry));
1529
1530 entry->next=NULL;
1531 entry->callback=callback;
1532 entry->in=in;
1533 entry->data1=data1;
1534 entry->data2=data2;
1535 entry->data3=data3;
1536
1537 if (jtag_callback_queue_head==NULL)
1538 {
1539 jtag_callback_queue_head=entry;
1540 jtag_callback_queue_tail=entry;
1541 } else
1542 {
1543 jtag_callback_queue_tail->next=entry;
1544 jtag_callback_queue_tail=entry;
1545 }
1546 }
1547
1548
1549 static int jtag_convert_to_callback4(u8 *in, jtag_callback_data_t data1, jtag_callback_data_t data2, jtag_callback_data_t data3)
1550 {
1551 ((jtag_callback1_t)data1)(in);
1552 return ERROR_OK;
1553 }
1554
1555 void jtag_add_callback(jtag_callback1_t callback, u8 *in)
1556 {
1557 jtag_add_callback4(jtag_convert_to_callback4, in, (jtag_callback_data_t)callback, 0, 0);
1558 }
1559 #endif
1560
1561 #ifndef HAVE_JTAG_MINIDRIVER_H
1562
1563 int interface_jtag_execute_queue(void)
1564 {
1565 int retval;
1566
1567 if (jtag==NULL)
1568 {
1569 LOG_ERROR("No JTAG interface configured yet. Issue 'init' command in startup scripts before communicating with targets.");
1570 return ERROR_FAIL;
1571 }
1572
1573 retval = jtag->execute_queue();
1574
1575 if (retval == ERROR_OK)
1576 {
1577 struct jtag_callback_entry *entry;
1578 for (entry=jtag_callback_queue_head; entry!=NULL; entry=entry->next)
1579 {
1580 retval=entry->callback(entry->in, entry->data1, entry->data2, entry->data3);
1581 if (retval!=ERROR_OK)
1582 break;
1583 }
1584 }
1585
1586 jtag_callback_queue_head = NULL;
1587 jtag_callback_queue_tail = NULL;
1588
1589 jtag_command_queue_reset();
1590
1591 return retval;
1592 }
1593 #endif
1594
1595 void jtag_execute_queue_noclear(void)
1596 {
1597 /* each flush can take as much as 1-2ms on high bandwidth low latency interfaces.
1598 * E.g. a JTAG over TCP/IP or USB....
1599 */
1600 jtag_flush_queue_count++;
1601
1602 int retval=interface_jtag_execute_queue();
1603 /* we keep the first error */
1604 if ((jtag_error==ERROR_OK)&&(retval!=ERROR_OK))
1605 {
1606 jtag_error=retval;
1607 }
1608 }
1609
1610 int jtag_execute_queue(void)
1611 {
1612 int retval;
1613 jtag_execute_queue_noclear();
1614 retval=jtag_error;
1615 jtag_error=ERROR_OK;
1616 return retval;
1617 }
1618
1619 int jtag_reset_callback(enum jtag_event event, void *priv)
1620 {
1621 jtag_tap_t *tap = priv;
1622
1623 LOG_DEBUG("-");
1624
1625 if (event == JTAG_TRST_ASSERTED)
1626 {
1627 buf_set_ones(tap->cur_instr, tap->ir_length);
1628 tap->bypass = 1;
1629 }
1630
1631 return ERROR_OK;
1632 }
1633
1634 void jtag_sleep(u32 us)
1635 {
1636 alive_sleep(us/1000);
1637 }
1638
1639 /* Try to examine chain layout according to IEEE 1149.1 §12
1640 */
1641 int jtag_examine_chain(void)
1642 {
1643 jtag_tap_t *tap;
1644 scan_field_t field;
1645 u8 idcode_buffer[JTAG_MAX_CHAIN_SIZE * 4];
1646 int i;
1647 int bit_count;
1648 int device_count = 0;
1649 u8 zero_check = 0x0;
1650 u8 one_check = 0xff;
1651
1652 field.tap = NULL;
1653 field.num_bits = sizeof(idcode_buffer) * 8;
1654 field.out_value = idcode_buffer;
1655
1656 field.in_value = idcode_buffer;
1657
1658
1659
1660
1661 for (i = 0; i < JTAG_MAX_CHAIN_SIZE; i++)
1662 {
1663 buf_set_u32(idcode_buffer, i * 32, 32, 0x000000FF);
1664 }
1665
1666 jtag_add_plain_dr_scan(1, &field, TAP_RESET);
1667 jtag_execute_queue();
1668
1669 for (i = 0; i < JTAG_MAX_CHAIN_SIZE * 4; i++)
1670 {
1671 zero_check |= idcode_buffer[i];
1672 one_check &= idcode_buffer[i];
1673 }
1674
1675 /* if there wasn't a single non-zero bit or if all bits were one, the scan isn't valid */
1676 if ((zero_check == 0x00) || (one_check == 0xff))
1677 {
1678 LOG_ERROR("JTAG communication failure, check connection, JTAG interface, target power etc.");
1679 return ERROR_JTAG_INIT_FAILED;
1680 }
1681
1682 /* point at the 1st tap */
1683 tap = jtag_NextEnabledTap(NULL);
1684 if( tap == NULL ){
1685 LOG_ERROR("JTAG: No taps enabled?");
1686 return ERROR_JTAG_INIT_FAILED;
1687 }
1688
1689 for (bit_count = 0; bit_count < (JTAG_MAX_CHAIN_SIZE * 32) - 31;)
1690 {
1691 u32 idcode = buf_get_u32(idcode_buffer, bit_count, 32);
1692 if ((idcode & 1) == 0)
1693 {
1694 /* LSB must not be 0, this indicates a device in bypass */
1695 LOG_WARNING("Tap/Device does not have IDCODE");
1696 idcode=0;
1697
1698 bit_count += 1;
1699 }
1700 else
1701 {
1702 u32 manufacturer;
1703 u32 part;
1704 u32 version;
1705
1706 /* some devices, such as AVR will output all 1's instead of TDI
1707 input value at end of chain. */
1708 if ((idcode == 0x000000FF)||(idcode == 0xFFFFFFFF))
1709 {
1710 int unexpected=0;
1711 /* End of chain (invalid manufacturer ID)
1712 *
1713 * The JTAG examine is the very first thing that happens
1714 *
1715 * A single JTAG device requires only 64 bits to be read back correctly.
1716 *
1717 * The code below adds a check that the rest of the data scanned (640 bits)
1718 * are all as expected. This helps diagnose/catch problems with the JTAG chain
1719 *
1720 * earlier and gives more helpful/explicit error messages.
1721 */
1722 for (bit_count += 32; bit_count < (JTAG_MAX_CHAIN_SIZE * 32) - 31;bit_count += 32)
1723 {
1724 idcode = buf_get_u32(idcode_buffer, bit_count, 32);
1725 if (unexpected||((idcode != 0x000000FF)&&(idcode != 0xFFFFFFFF)))
1726 {
1727 LOG_WARNING("Unexpected idcode after end of chain! %d 0x%08x", bit_count, idcode);
1728 unexpected = 1;
1729 }
1730 }
1731
1732 break;
1733 }
1734
1735 #define EXTRACT_MFG(X) (((X) & 0xffe) >> 1)
1736 manufacturer = EXTRACT_MFG(idcode);
1737 #define EXTRACT_PART(X) (((X) & 0xffff000) >> 12)
1738 part = EXTRACT_PART(idcode);
1739 #define EXTRACT_VER(X) (((X) & 0xf0000000) >> 28)
1740 version = EXTRACT_VER(idcode);
1741
1742 LOG_INFO("JTAG tap: %s tap/device found: 0x%8.8x (Manufacturer: 0x%3.3x, Part: 0x%4.4x, Version: 0x%1.1x)",
1743 ((tap != NULL) ? (tap->dotted_name) : "(not-named)"),
1744 idcode, manufacturer, part, version);
1745
1746 bit_count += 32;
1747 }
1748 if (tap)
1749 {
1750 tap->idcode = idcode;
1751
1752 if (tap->expected_ids_cnt > 0) {
1753 /* Loop over the expected identification codes and test for a match */
1754 u8 ii;
1755 for (ii = 0; ii < tap->expected_ids_cnt; ii++) {
1756 if( tap->idcode == tap->expected_ids[ii] ){
1757 break;
1758 }
1759 }
1760
1761 /* If none of the expected ids matched, log an error */
1762 if (ii == tap->expected_ids_cnt) {
1763 LOG_ERROR("JTAG tap: %s got: 0x%08x (mfg: 0x%3.3x, part: 0x%4.4x, ver: 0x%1.1x)",
1764 tap->dotted_name,
1765 idcode,
1766 EXTRACT_MFG( tap->idcode ),
1767 EXTRACT_PART( tap->idcode ),
1768 EXTRACT_VER( tap->idcode ) );
1769 for (ii = 0; ii < tap->expected_ids_cnt; ii++) {
1770 LOG_ERROR("JTAG tap: %s expected %hhu of %hhu: 0x%08x (mfg: 0x%3.3x, part: 0x%4.4x, ver: 0x%1.1x)",
1771 tap->dotted_name,
1772 ii + 1,
1773 tap->expected_ids_cnt,
1774 tap->expected_ids[ii],
1775 EXTRACT_MFG( tap->expected_ids[ii] ),
1776 EXTRACT_PART( tap->expected_ids[ii] ),
1777 EXTRACT_VER( tap->expected_ids[ii] ) );
1778 }
1779
1780 return ERROR_JTAG_INIT_FAILED;
1781 } else {
1782 LOG_INFO("JTAG Tap/device matched");
1783 }
1784 } else {
1785 #if 0
1786 LOG_INFO("JTAG TAP ID: 0x%08x - Unknown - please report (A) chipname and (B) idcode to the openocd project",
1787 tap->idcode);
1788 #endif
1789 }
1790 tap = jtag_NextEnabledTap(tap);
1791 }
1792 device_count++;
1793 }
1794
1795 /* see if number of discovered devices matches configuration */
1796 if (device_count != jtag_NumEnabledTaps())
1797 {
1798 LOG_ERROR("number of discovered devices in JTAG chain (%i) doesn't match (enabled) configuration (%i), total taps: %d",
1799 device_count, jtag_NumEnabledTaps(), jtag_NumTotalTaps());
1800 LOG_ERROR("check the config file and ensure proper JTAG communication (connections, speed, ...)");
1801 return ERROR_JTAG_INIT_FAILED;
1802 }
1803
1804 return ERROR_OK;
1805 }
1806
1807 int jtag_validate_chain(void)
1808 {
1809 jtag_tap_t *tap;
1810 int total_ir_length = 0;
1811 u8 *ir_test = NULL;
1812 scan_field_t field;
1813 int chain_pos = 0;
1814
1815 tap = NULL;
1816 total_ir_length = 0;
1817 for(;;){
1818 tap = jtag_NextEnabledTap(tap);
1819 if( tap == NULL ){
1820 break;
1821 }
1822 total_ir_length += tap->ir_length;
1823 }
1824
1825 total_ir_length += 2;
1826 ir_test = malloc(CEIL(total_ir_length, 8));
1827 buf_set_ones(ir_test, total_ir_length);
1828
1829 field.tap = NULL;
1830 field.num_bits = total_ir_length;
1831 field.out_value = ir_test;
1832 field.in_value = ir_test;
1833
1834
1835 jtag_add_plain_ir_scan(1, &field, TAP_RESET);
1836 jtag_execute_queue();
1837
1838 tap = NULL;
1839 chain_pos = 0;
1840 int val;
1841 for(;;){
1842 tap = jtag_NextEnabledTap(tap);
1843 if( tap == NULL ){
1844 break;
1845 }
1846
1847 val = buf_get_u32(ir_test, chain_pos, 2);
1848 if (val != 0x1)
1849 {
1850 char *cbuf = buf_to_str(ir_test, total_ir_length, 16);
1851 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);
1852 free(cbuf);
1853 free(ir_test);
1854 return ERROR_JTAG_INIT_FAILED;
1855 }
1856 chain_pos += tap->ir_length;
1857 }
1858
1859 val = buf_get_u32(ir_test, chain_pos, 2);
1860 if (val != 0x3)
1861 {
1862 char *cbuf = buf_to_str(ir_test, total_ir_length, 16);
1863 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);
1864 free(cbuf);
1865 free(ir_test);
1866 return ERROR_JTAG_INIT_FAILED;
1867 }
1868
1869 free(ir_test);
1870
1871 return ERROR_OK;
1872 }
1873
1874 enum jtag_tap_cfg_param {
1875 JCFG_EVENT
1876 };
1877
1878 static Jim_Nvp nvp_config_opts[] = {
1879 { .name = "-event", .value = JCFG_EVENT },
1880
1881 { .name = NULL, .value = -1 }
1882 };
1883
1884 static int jtag_tap_configure_cmd( Jim_GetOptInfo *goi, jtag_tap_t * tap)
1885 {
1886 Jim_Nvp *n;
1887 Jim_Obj *o;
1888 int e;
1889
1890 /* parse config or cget options */
1891 while (goi->argc > 0) {
1892 Jim_SetEmptyResult (goi->interp);
1893
1894 e = Jim_GetOpt_Nvp(goi, nvp_config_opts, &n);
1895 if (e != JIM_OK) {
1896 Jim_GetOpt_NvpUnknown(goi, nvp_config_opts, 0);
1897 return e;
1898 }
1899
1900 switch (n->value) {
1901 case JCFG_EVENT:
1902 if (goi->argc == 0) {
1903 Jim_WrongNumArgs( goi->interp, goi->argc, goi->argv, "-event ?event-name? ..." );
1904 return JIM_ERR;
1905 }
1906
1907 e = Jim_GetOpt_Nvp( goi, nvp_jtag_tap_event, &n );
1908 if (e != JIM_OK) {
1909 Jim_GetOpt_NvpUnknown(goi, nvp_jtag_tap_event, 1);
1910 return e;
1911 }
1912
1913 if (goi->isconfigure) {
1914 if (goi->argc != 1) {
1915 Jim_WrongNumArgs(goi->interp, goi->argc, goi->argv, "-event ?event-name? ?EVENT-BODY?");
1916 return JIM_ERR;
1917 }
1918 } else {
1919 if (goi->argc != 0) {
1920 Jim_WrongNumArgs(goi->interp, goi->argc, goi->argv, "-event ?event-name?");
1921 return JIM_ERR;
1922 }
1923 }
1924
1925 {
1926 jtag_tap_event_action_t *jteap;
1927
1928 jteap = tap->event_action;
1929 /* replace existing? */
1930 while (jteap) {
1931 if (jteap->event == (enum jtag_tap_event)n->value) {
1932 break;
1933 }
1934 jteap = jteap->next;
1935 }
1936
1937 if (goi->isconfigure) {
1938 if (jteap == NULL) {
1939 /* create new */
1940 jteap = calloc(1, sizeof (*jteap));
1941 }
1942 jteap->event = n->value;
1943 Jim_GetOpt_Obj( goi, &o);
1944 if (jteap->body) {
1945 Jim_DecrRefCount(interp, jteap->body);
1946 }
1947 jteap->body = Jim_DuplicateObj(goi->interp, o);
1948 Jim_IncrRefCount(jteap->body);
1949
1950 /* add to head of event list */
1951 jteap->next = tap->event_action;
1952 tap->event_action = jteap;
1953 Jim_SetEmptyResult(goi->interp);
1954 } else {
1955 /* get */
1956 if (jteap == NULL) {
1957 Jim_SetEmptyResult(goi->interp);
1958 } else {
1959 Jim_SetResult(goi->interp, Jim_DuplicateObj(goi->interp, jteap->body));
1960 }
1961 }
1962 }
1963 /* loop for more */
1964 break;
1965 }
1966 } /* while (goi->argc) */
1967
1968 return JIM_OK;
1969 }
1970
1971 static int jim_newtap_cmd( Jim_GetOptInfo *goi )
1972 {
1973 jtag_tap_t *pTap;
1974 jtag_tap_t **ppTap;
1975 jim_wide w;
1976 int x;
1977 int e;
1978 int reqbits;
1979 Jim_Nvp *n;
1980 char *cp;
1981 const Jim_Nvp opts[] = {
1982 #define NTAP_OPT_IRLEN 0
1983 { .name = "-irlen" , .value = NTAP_OPT_IRLEN },
1984 #define NTAP_OPT_IRMASK 1
1985 { .name = "-irmask" , .value = NTAP_OPT_IRMASK },
1986 #define NTAP_OPT_IRCAPTURE 2
1987 { .name = "-ircapture" , .value = NTAP_OPT_IRCAPTURE },
1988 #define NTAP_OPT_ENABLED 3
1989 { .name = "-enable" , .value = NTAP_OPT_ENABLED },
1990 #define NTAP_OPT_DISABLED 4
1991 { .name = "-disable" , .value = NTAP_OPT_DISABLED },
1992 #define NTAP_OPT_EXPECTED_ID 5
1993 { .name = "-expected-id" , .value = NTAP_OPT_EXPECTED_ID },
1994 { .name = NULL , .value = -1 },
1995 };
1996
1997 pTap = malloc( sizeof(jtag_tap_t) );
1998 memset( pTap, 0, sizeof(*pTap) );
1999 if( !pTap ){
2000 Jim_SetResult_sprintf( goi->interp, "no memory");
2001 return JIM_ERR;
2002 }
2003 /*
2004 * we expect CHIP + TAP + OPTIONS
2005 * */
2006 if( goi->argc < 3 ){
2007 Jim_SetResult_sprintf(goi->interp, "Missing CHIP TAP OPTIONS ....");
2008 return JIM_ERR;
2009 }
2010 Jim_GetOpt_String( goi, &cp, NULL );
2011 pTap->chip = strdup(cp);
2012
2013 Jim_GetOpt_String( goi, &cp, NULL );
2014 pTap->tapname = strdup(cp);
2015
2016 /* name + dot + name + null */
2017 x = strlen(pTap->chip) + 1 + strlen(pTap->tapname) + 1;
2018 cp = malloc( x );
2019 sprintf( cp, "%s.%s", pTap->chip, pTap->tapname );
2020 pTap->dotted_name = cp;
2021
2022 LOG_DEBUG("Creating New Tap, Chip: %s, Tap: %s, Dotted: %s, %d params",
2023 pTap->chip, pTap->tapname, pTap->dotted_name, goi->argc);
2024
2025 /* default is enabled */
2026 pTap->enabled = 1;
2027
2028 /* deal with options */
2029 #define NTREQ_IRLEN 1
2030 #define NTREQ_IRCAPTURE 2
2031 #define NTREQ_IRMASK 4
2032
2033 /* clear them as we find them */
2034 reqbits = (NTREQ_IRLEN | NTREQ_IRCAPTURE | NTREQ_IRMASK);
2035
2036 while( goi->argc ){
2037 e = Jim_GetOpt_Nvp( goi, opts, &n );
2038 if( e != JIM_OK ){
2039 Jim_GetOpt_NvpUnknown( goi, opts, 0 );
2040 return e;
2041 }
2042 LOG_DEBUG("Processing option: %s", n->name );
2043 switch( n->value ){
2044 case NTAP_OPT_ENABLED:
2045 pTap->enabled = 1;
2046 break;
2047 case NTAP_OPT_DISABLED:
2048 pTap->enabled = 0;
2049 break;
2050 case NTAP_OPT_EXPECTED_ID:
2051 {
2052 u32 *new_expected_ids;
2053
2054 e = Jim_GetOpt_Wide( goi, &w );
2055 if( e != JIM_OK) {
2056 Jim_SetResult_sprintf(goi->interp, "option: %s bad parameter", n->name);
2057 return e;
2058 }
2059
2060 new_expected_ids = malloc(sizeof(u32) * (pTap->expected_ids_cnt + 1));
2061 if (new_expected_ids == NULL) {
2062 Jim_SetResult_sprintf( goi->interp, "no memory");
2063 return JIM_ERR;
2064 }
2065
2066 memcpy(new_expected_ids, pTap->expected_ids, sizeof(u32) * pTap->expected_ids_cnt);
2067
2068 new_expected_ids[pTap->expected_ids_cnt] = w;
2069
2070 free(pTap->expected_ids);
2071 pTap->expected_ids = new_expected_ids;
2072 pTap->expected_ids_cnt++;
2073 break;
2074 }
2075 case NTAP_OPT_IRLEN:
2076 case NTAP_OPT_IRMASK:
2077 case NTAP_OPT_IRCAPTURE:
2078 e = Jim_GetOpt_Wide( goi, &w );
2079 if( e != JIM_OK ){
2080 Jim_SetResult_sprintf( goi->interp, "option: %s bad parameter", n->name );
2081 return e;
2082 }
2083 if( (w < 0) || (w > 0xffff) ){
2084 /* wacky value */
2085 Jim_SetResult_sprintf( goi->interp, "option: %s - wacky value: %d (0x%x)",
2086 n->name, (int)(w), (int)(w));
2087 return JIM_ERR;
2088 }
2089 switch(n->value){
2090 case NTAP_OPT_IRLEN:
2091 pTap->ir_length = w;
2092 reqbits &= (~(NTREQ_IRLEN));
2093 break;
2094 case NTAP_OPT_IRMASK:
2095 pTap->ir_capture_mask = w;
2096 reqbits &= (~(NTREQ_IRMASK));
2097 break;
2098 case NTAP_OPT_IRCAPTURE:
2099 pTap->ir_capture_value = w;
2100 reqbits &= (~(NTREQ_IRCAPTURE));
2101 break;
2102 }
2103 } /* switch(n->value) */
2104 } /* while( goi->argc ) */
2105
2106 /* Did we get all the options? */
2107 if( reqbits ){
2108 // no
2109 Jim_SetResult_sprintf( goi->interp,
2110 "newtap: %s missing required parameters",
2111 pTap->dotted_name);
2112 /* TODO: Tell user what is missing :-( */
2113 /* no memory leaks pelase */
2114 free(((void *)(pTap->expected_ids)));
2115 free(((void *)(pTap->chip)));
2116 free(((void *)(pTap->tapname)));
2117 free(((void *)(pTap->dotted_name)));
2118 free(((void *)(pTap)));
2119 return JIM_ERR;
2120 }
2121
2122 pTap->expected = malloc( pTap->ir_length );
2123 pTap->expected_mask = malloc( pTap->ir_length );
2124 pTap->cur_instr = malloc( pTap->ir_length );
2125
2126 buf_set_u32( pTap->expected,
2127 0,
2128 pTap->ir_length,
2129 pTap->ir_capture_value );
2130 buf_set_u32( pTap->expected_mask,
2131 0,
2132 pTap->ir_length,
2133 pTap->ir_capture_mask );
2134 buf_set_ones( pTap->cur_instr,
2135 pTap->ir_length );
2136
2137 pTap->bypass = 1;
2138
2139 jtag_register_event_callback(jtag_reset_callback, pTap );
2140
2141 ppTap = &(jtag_all_taps);
2142 while( (*ppTap) != NULL ){
2143 ppTap = &((*ppTap)->next_tap);
2144 }
2145 *ppTap = pTap;
2146 {
2147 static int n_taps = 0;
2148 pTap->abs_chain_position = n_taps++;
2149 }
2150 LOG_DEBUG( "Created Tap: %s @ abs position %d, irlen %d, capture: 0x%x mask: 0x%x",
2151 (*ppTap)->dotted_name,
2152 (*ppTap)->abs_chain_position,
2153 (*ppTap)->ir_length,
2154 (*ppTap)->ir_capture_value,
2155 (*ppTap)->ir_capture_mask );
2156
2157 return ERROR_OK;
2158 }
2159
2160 static int jim_jtag_command( Jim_Interp *interp, int argc, Jim_Obj *const *argv )
2161 {
2162 Jim_GetOptInfo goi;
2163 int e;
2164 Jim_Nvp *n;
2165 Jim_Obj *o;
2166 struct command_context_s *context;
2167
2168 enum {
2169 JTAG_CMD_INTERFACE,
2170 JTAG_CMD_INIT_RESET,
2171 JTAG_CMD_NEWTAP,
2172 JTAG_CMD_TAPENABLE,
2173 JTAG_CMD_TAPDISABLE,
2174 JTAG_CMD_TAPISENABLED,
2175 JTAG_CMD_CONFIGURE,
2176 JTAG_CMD_CGET
2177 };
2178
2179 const Jim_Nvp jtag_cmds[] = {
2180 { .name = "interface" , .value = JTAG_CMD_INTERFACE },
2181 { .name = "arp_init-reset", .value = JTAG_CMD_INIT_RESET },
2182 { .name = "newtap" , .value = JTAG_CMD_NEWTAP },
2183 { .name = "tapisenabled" , .value = JTAG_CMD_TAPISENABLED },
2184 { .name = "tapenable" , .value = JTAG_CMD_TAPENABLE },
2185 { .name = "tapdisable" , .value = JTAG_CMD_TAPDISABLE },
2186 { .name = "configure" , .value = JTAG_CMD_CONFIGURE },
2187 { .name = "cget" , .value = JTAG_CMD_CGET },
2188
2189 { .name = NULL, .value = -1 },
2190 };
2191
2192 context = Jim_GetAssocData(interp, "context");
2193 /* go past the command */
2194 Jim_GetOpt_Setup( &goi, interp, argc-1, argv+1 );
2195
2196 e = Jim_GetOpt_Nvp( &goi, jtag_cmds, &n );
2197 if( e != JIM_OK ){
2198 Jim_GetOpt_NvpUnknown( &goi, jtag_cmds, 0 );
2199 return e;
2200 }
2201 Jim_SetEmptyResult( goi.interp );
2202 switch( n->value ){
2203 case JTAG_CMD_INTERFACE:
2204 /* return the name of the interface */
2205 /* TCL code might need to know the exact type... */
2206 /* FUTURE: we allow this as a means to "set" the interface. */
2207 if( goi.argc != 0 ){
2208 Jim_WrongNumArgs( goi.interp, 1, goi.argv-1, "(no params)");
2209 return JIM_ERR;
2210 }
2211 Jim_SetResultString( goi.interp, jtag_interface->name, -1 );
2212 return JIM_OK;
2213 case JTAG_CMD_INIT_RESET:
2214 if( goi.argc != 0 ){
2215 Jim_WrongNumArgs( goi.interp, 1, goi.argv-1, "(no params)");
2216 return JIM_ERR;
2217 }
2218 e = jtag_init_reset(context);
2219 if( e != ERROR_OK ){
2220 Jim_SetResult_sprintf( goi.interp, "error: %d", e);
2221 return JIM_ERR;
2222 }
2223 return JIM_OK;
2224 case JTAG_CMD_NEWTAP:
2225 return jim_newtap_cmd( &goi );
2226 break;
2227 case JTAG_CMD_TAPISENABLED:
2228 case JTAG_CMD_TAPENABLE:
2229 case JTAG_CMD_TAPDISABLE:
2230 if( goi.argc != 1 ){
2231 Jim_SetResultString( goi.interp, "Too many parameters",-1 );
2232 return JIM_ERR;
2233 }
2234
2235 {
2236 jtag_tap_t *t;
2237 t = jtag_TapByJimObj( goi.interp, goi.argv[0] );
2238 if( t == NULL ){
2239 return JIM_ERR;
2240 }
2241 switch( n->value ){
2242 case JTAG_CMD_TAPISENABLED:
2243 e = t->enabled;
2244 break;
2245 case JTAG_CMD_TAPENABLE:
2246 jtag_tap_handle_event( t, JTAG_TAP_EVENT_ENABLE);
2247 e = 1;
2248 t->enabled = e;
2249 break;
2250 case JTAG_CMD_TAPDISABLE:
2251 jtag_tap_handle_event( t, JTAG_TAP_EVENT_DISABLE);
2252 e = 0;
2253 t->enabled = e;
2254 break;
2255 }
2256 Jim_SetResult( goi.interp, Jim_NewIntObj( goi.interp, e ) );
2257 return JIM_OK;
2258 }
2259 break;
2260
2261 case JTAG_CMD_CGET:
2262 if( goi.argc < 2 ){
2263 Jim_WrongNumArgs( goi.interp, 0, NULL, "?tap-name? -option ...");
2264 return JIM_ERR;
2265 }
2266
2267 {
2268 jtag_tap_t *t;
2269
2270 Jim_GetOpt_Obj(&goi, &o);
2271 t = jtag_TapByJimObj( goi.interp, o );
2272 if( t == NULL ){
2273 return JIM_ERR;
2274 }
2275
2276 goi.isconfigure = 0;
2277 return jtag_tap_configure_cmd( &goi, t);
2278 }
2279 break;
2280
2281 case JTAG_CMD_CONFIGURE:
2282 if( goi.argc < 3 ){
2283 Jim_WrongNumArgs( goi.interp, 0, NULL, "?tap-name? -option ?VALUE? ...");
2284 return JIM_ERR;
2285 }
2286
2287 {
2288 jtag_tap_t *t;
2289
2290 Jim_GetOpt_Obj(&goi, &o);
2291 t = jtag_TapByJimObj( goi.interp, o );
2292 if( t == NULL ){
2293 return JIM_ERR;
2294 }
2295
2296 goi.isconfigure = 1;
2297 return jtag_tap_configure_cmd( &goi, t);
2298 }
2299 }
2300
2301 return JIM_ERR;
2302 }
2303
2304 int jtag_register_commands(struct command_context_s *cmd_ctx)
2305 {
2306 register_jim( cmd_ctx, "jtag", jim_jtag_command, "perform jtag tap actions");
2307
2308 register_command(cmd_ctx, NULL, "interface", handle_interface_command,
2309 COMMAND_CONFIG, "try to configure interface");
2310 register_command(cmd_ctx, NULL, "jtag_speed", handle_jtag_speed_command,
2311 COMMAND_ANY, "(DEPRECATED) set jtag speed (if supported)");
2312 register_command(cmd_ctx, NULL, "jtag_khz", handle_jtag_khz_command,
2313 COMMAND_ANY, "set maximum jtag speed (if supported); "
2314 "parameter is maximum khz, or 0 for adaptive clocking (RTCK).");
2315 register_command(cmd_ctx, NULL, "jtag_device", handle_jtag_device_command,
2316 COMMAND_CONFIG, "(DEPRECATED) jtag_device <ir_length> <ir_expected> <ir_mask>");
2317 register_command(cmd_ctx, NULL, "reset_config", handle_reset_config_command,
2318 COMMAND_ANY,
2319 "[none/trst_only/srst_only/trst_and_srst] [srst_pulls_trst/trst_pulls_srst] [combined/separate] [trst_push_pull/trst_open_drain] [srst_push_pull/srst_open_drain]");
2320 register_command(cmd_ctx, NULL, "jtag_nsrst_delay", handle_jtag_nsrst_delay_command,
2321 COMMAND_ANY, "jtag_nsrst_delay <ms> - delay after deasserting srst in ms");
2322 register_command(cmd_ctx, NULL, "jtag_ntrst_delay", handle_jtag_ntrst_delay_command,
2323 COMMAND_ANY, "jtag_ntrst_delay <ms> - delay after deasserting trst in ms");
2324
2325 register_command(cmd_ctx, NULL, "scan_chain", handle_scan_chain_command,
2326 COMMAND_EXEC, "print current scan chain configuration");
2327
2328 register_command(cmd_ctx, NULL, "endstate", handle_endstate_command,
2329 COMMAND_EXEC, "finish JTAG operations in <tap_state>");
2330 register_command(cmd_ctx, NULL, "jtag_reset", handle_jtag_reset_command,
2331 COMMAND_EXEC, "toggle reset lines <trst> <srst>");
2332 register_command(cmd_ctx, NULL, "runtest", handle_runtest_command,
2333 COMMAND_EXEC, "move to Run-Test/Idle, and execute <num_cycles>");
2334 register_command(cmd_ctx, NULL, "irscan", handle_irscan_command,
2335 COMMAND_EXEC, "execute IR scan <device> <instr> [dev2] [instr2] ...");
2336 register_jim(cmd_ctx, "drscan", Jim_Command_drscan, "execute DR scan <device> <num_bits> <value> <num_bits1> <value2> ...");
2337 register_jim(cmd_ctx, "flush_count", Jim_Command_flush_count, "returns number of times the JTAG queue has been flushed");
2338
2339 register_command(cmd_ctx, NULL, "verify_ircapture", handle_verify_ircapture_command,
2340 COMMAND_ANY, "verify value captured during Capture-IR <enable|disable>");
2341 register_command(cmd_ctx, NULL, "verify_jtag", handle_verify_jtag_command,
2342 COMMAND_ANY, "verify value capture <enable|disable>");
2343 register_command(cmd_ctx, NULL, "tms_sequence", handle_tms_sequence_command,
2344 COMMAND_ANY, "choose short(default) or long tms_sequence <short|long>");
2345 return ERROR_OK;
2346 }
2347
2348 int jtag_interface_init(struct command_context_s *cmd_ctx)
2349 {
2350 if (jtag)
2351 return ERROR_OK;
2352
2353 if (!jtag_interface)
2354 {
2355 /* nothing was previously specified by "interface" command */
2356 LOG_ERROR("JTAG interface has to be specified, see \"interface\" command");
2357 return ERROR_JTAG_INVALID_INTERFACE;
2358 }
2359 if(hasKHz)
2360 {
2361 jtag_interface->khz(speed_khz, &jtag_speed);
2362 hasKHz = 0;
2363 }
2364
2365 if (jtag_interface->init() != ERROR_OK)
2366 return ERROR_JTAG_INIT_FAILED;
2367
2368 jtag = jtag_interface;
2369 return ERROR_OK;
2370 }
2371
2372 static int jtag_init_inner(struct command_context_s *cmd_ctx)
2373 {
2374 jtag_tap_t *tap;
2375 int retval;
2376
2377 LOG_DEBUG("Init JTAG chain");
2378
2379 tap = jtag_NextEnabledTap(NULL);
2380 if( tap == NULL ){
2381 LOG_ERROR("There are no enabled taps?");
2382 return ERROR_JTAG_INIT_FAILED;
2383 }
2384
2385 jtag_add_tlr();
2386 if ((retval=jtag_execute_queue())!=ERROR_OK)
2387 return retval;
2388
2389 /* examine chain first, as this could discover the real chain layout */
2390 if (jtag_examine_chain() != ERROR_OK)
2391 {
2392 LOG_ERROR("trying to validate configured JTAG chain anyway...");
2393 }
2394
2395 if (jtag_validate_chain() != ERROR_OK)
2396 {
2397 LOG_WARNING("Could not validate JTAG chain, continuing anyway...");
2398 }
2399
2400 return ERROR_OK;
2401 }
2402
2403 int jtag_interface_quit(void)
2404 {
2405 if (!jtag || !jtag->quit)
2406 return ERROR_OK;
2407
2408 // close the JTAG interface
2409 int result = jtag->quit();
2410 if (ERROR_OK != result)
2411 LOG_ERROR("failed: %d", result);
2412
2413 return ERROR_OK;
2414 }
2415
2416
2417 int jtag_init_reset(struct command_context_s *cmd_ctx)
2418 {
2419 int retval;
2420
2421 if ((retval=jtag_interface_init(cmd_ctx)) != ERROR_OK)
2422 return retval;
2423
2424 LOG_DEBUG("Trying to bring the JTAG controller to life by asserting TRST / RESET");
2425
2426 /* Reset can happen after a power cycle.
2427 *
2428 * Ideally we would only assert TRST or run RESET before the target reset.
2429 *
2430 * However w/srst_pulls_trst, trst is asserted together with the target
2431 * reset whether we want it or not.
2432 *
2433 * NB! Some targets have JTAG circuitry disabled until a
2434 * trst & srst has been asserted.
2435 *
2436 * NB! here we assume nsrst/ntrst delay are sufficient!
2437 *
2438 * NB! order matters!!!! srst *can* disconnect JTAG circuitry
2439 *
2440 */
2441 jtag_add_reset(1, 0); /* RESET or TRST */
2442 if (jtag_reset_config & RESET_HAS_SRST)
2443 {
2444 jtag_add_reset(1, 1);
2445 if ((jtag_reset_config & RESET_SRST_PULLS_TRST)==0)
2446 jtag_add_reset(0, 1);
2447 }
2448 jtag_add_reset(0, 0);
2449 if ((retval = jtag_execute_queue()) != ERROR_OK)
2450 return retval;
2451
2452 /* Check that we can communication on the JTAG chain + eventually we want to
2453 * be able to perform enumeration only after OpenOCD has started
2454 * telnet and GDB server
2455 *
2456 * That would allow users to more easily perform any magic they need to before
2457 * reset happens.
2458 */
2459 return jtag_init_inner(cmd_ctx);
2460 }
2461
2462 int jtag_init(struct command_context_s *cmd_ctx)
2463 {
2464 int retval;
2465 if ((retval=jtag_interface_init(cmd_ctx)) != ERROR_OK)
2466 return retval;
2467 if (jtag_init_inner(cmd_ctx)==ERROR_OK)
2468 {
2469 return ERROR_OK;
2470 }
2471 return jtag_init_reset(cmd_ctx);
2472 }
2473
2474 static int default_khz(int khz, int *jtag_speed)
2475 {
2476 LOG_ERROR("Translation from khz to jtag_speed not implemented");
2477 return ERROR_FAIL;
2478 }
2479
2480 static int default_speed_div(int speed, int *khz)
2481 {
2482 LOG_ERROR("Translation from jtag_speed to khz not implemented");
2483 return ERROR_FAIL;
2484 }
2485
2486 static int default_power_dropout(int *dropout)
2487 {
2488 *dropout=0; /* by default we can't detect power dropout */
2489 return ERROR_OK;
2490 }
2491
2492 static int default_srst_asserted(int *srst_asserted)
2493 {
2494 *srst_asserted=0; /* by default we can't detect srst asserted */
2495 return ERROR_OK;
2496 }
2497
2498 static int handle_interface_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2499 {
2500 int i;
2501 int retval;
2502
2503 /* check whether the interface is already configured */
2504 if (jtag_interface)
2505 {
2506 LOG_WARNING("Interface already configured, ignoring");
2507 return ERROR_OK;
2508 }
2509
2510 /* interface name is a mandatory argument */
2511 if (argc < 1 || args[0][0] == '\0')
2512 {
2513 return ERROR_COMMAND_SYNTAX_ERROR;
2514 }
2515
2516 for (i=0; jtag_interfaces[i]; i++)
2517 {
2518 if (strcmp(args[0], jtag_interfaces[i]->name) == 0)
2519 {
2520 if ((retval = jtag_interfaces[i]->register_commands(cmd_ctx)) != ERROR_OK)
2521 {
2522 return retval;
2523 }
2524
2525 jtag_interface = jtag_interfaces[i];
2526
2527 if (jtag_interface->khz == NULL)
2528 {
2529 jtag_interface->khz = default_khz;
2530 }
2531 if (jtag_interface->speed_div == NULL)
2532 {
2533 jtag_interface->speed_div = default_speed_div;
2534 }
2535 if (jtag_interface->power_dropout == NULL)
2536 {
2537 jtag_interface->power_dropout = default_power_dropout;
2538 }
2539 if (jtag_interface->srst_asserted == NULL)
2540 {
2541 jtag_interface->srst_asserted = default_srst_asserted;
2542 }
2543
2544 return ERROR_OK;
2545 }
2546 }
2547
2548 /* no valid interface was found (i.e. the configuration option,
2549 * didn't match one of the compiled-in interfaces
2550 */
2551 LOG_ERROR("No valid jtag interface found (%s)", args[0]);
2552 LOG_ERROR("compiled-in jtag interfaces:");
2553 for (i = 0; jtag_interfaces[i]; i++)
2554 {
2555 LOG_ERROR("%i: %s", i, jtag_interfaces[i]->name);
2556 }
2557
2558 return ERROR_JTAG_INVALID_INTERFACE;
2559 }
2560
2561 static int handle_jtag_device_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2562 {
2563 int e;
2564 char buf[1024];
2565 Jim_Obj *newargs[ 10 ];
2566 /*
2567 * CONVERT SYNTAX
2568 * argv[-1] = command
2569 * argv[ 0] = ir length
2570 * argv[ 1] = ir capture
2571 * argv[ 2] = ir mask
2572 * argv[ 3] = not actually used by anything but in the docs
2573 */
2574
2575 if( argc < 4 ){
2576 command_print( cmd_ctx, "OLD DEPRECATED SYNTAX: Please use the NEW syntax");
2577 return ERROR_OK;
2578 }
2579 command_print( cmd_ctx, "OLD SYNTAX: DEPRECATED - translating to new syntax");
2580 command_print( cmd_ctx, "jtag newtap CHIP TAP -irlen %s -ircapture %s -irvalue %s",
2581 args[0],
2582 args[1],
2583 args[2] );
2584 command_print( cmd_ctx, "Example: STM32 has 2 taps, the cortexM3(len4) + boundaryscan(len5)");
2585 command_print( cmd_ctx, "jtag newtap stm32 cortexm3 ....., thus creating the tap: \"stm32.cortexm3\"");
2586 command_print( cmd_ctx, "jtag newtap stm32 boundary ....., and the tap: \"stm32.boundary\"");
2587 command_print( cmd_ctx, "And then refer to the taps by the dotted name.");
2588
2589 newargs[0] = Jim_NewStringObj( interp, "jtag", -1 );
2590 newargs[1] = Jim_NewStringObj( interp, "newtap", -1 );
2591 sprintf( buf, "chip%d", jtag_NumTotalTaps() );
2592 newargs[2] = Jim_NewStringObj( interp, buf, -1 );
2593 sprintf( buf, "tap%d", jtag_NumTotalTaps() );
2594 newargs[3] = Jim_NewStringObj( interp, buf, -1 );
2595 newargs[4] = Jim_NewStringObj( interp, "-irlen", -1 );
2596 newargs[5] = Jim_NewStringObj( interp, args[0], -1 );
2597 newargs[6] = Jim_NewStringObj( interp, "-ircapture", -1 );
2598 newargs[7] = Jim_NewStringObj( interp, args[1], -1 );
2599 newargs[8] = Jim_NewStringObj( interp, "-irmask", -1 );
2600 newargs[9] = Jim_NewStringObj( interp, args[2], -1 );
2601
2602 command_print( cmd_ctx, "NEW COMMAND:");
2603 sprintf( buf, "%s %s %s %s %s %s %s %s %s %s",
2604 Jim_GetString( newargs[0], NULL ),
2605 Jim_GetString( newargs[1], NULL ),
2606 Jim_GetString( newargs[2], NULL ),
2607 Jim_GetString( newargs[3], NULL ),
2608 Jim_GetString( newargs[4], NULL ),
2609 Jim_GetString( newargs[5], NULL ),
2610 Jim_GetString( newargs[6], NULL ),
2611 Jim_GetString( newargs[7], NULL ),
2612 Jim_GetString( newargs[8], NULL ),
2613 Jim_GetString( newargs[9], NULL ) );
2614
2615 e = jim_jtag_command( interp, 10, newargs );
2616 if( e != JIM_OK ){
2617 command_print( cmd_ctx, "%s", Jim_GetString( Jim_GetResult(interp), NULL ) );
2618 }
2619 return e;
2620 }
2621
2622 static int handle_scan_chain_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2623 {
2624 jtag_tap_t *tap;
2625
2626 tap = jtag_all_taps;
2627 command_print(cmd_ctx, " TapName | Enabled | IdCode Expected IrLen IrCap IrMask Instr ");
2628 command_print(cmd_ctx, "---|--------------------|---------|------------|------------|------|------|------|---------");
2629
2630 while( tap ){
2631 u32 expected, expected_mask, cur_instr, ii;
2632 expected = buf_get_u32(tap->expected, 0, tap->ir_length);
2633 expected_mask = buf_get_u32(tap->expected_mask, 0, tap->ir_length);
2634 cur_instr = buf_get_u32(tap->cur_instr, 0, tap->ir_length);
2635
2636 command_print(cmd_ctx,
2637 "%2d | %-18s | %c | 0x%08x | 0x%08x | 0x%02x | 0x%02x | 0x%02x | 0x%02x",
2638 tap->abs_chain_position,
2639 tap->dotted_name,
2640 tap->enabled ? 'Y' : 'n',
2641 tap->idcode,
2642 (tap->expected_ids_cnt > 0 ? tap->expected_ids[0] : 0),
2643 tap->ir_length,
2644 expected,
2645 expected_mask,
2646 cur_instr);
2647
2648 for (ii = 1; ii < tap->expected_ids_cnt; ii++) {
2649 command_print(cmd_ctx, " | | | | 0x%08x | | | | ",
2650 tap->expected_ids[ii]);
2651 }
2652
2653 tap = tap->next_tap;
2654 }
2655
2656 return ERROR_OK;
2657 }
2658
2659 static int handle_reset_config_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2660 {
2661 int new_cfg = 0;
2662 int mask = 0;
2663
2664 if (argc < 1)
2665 return ERROR_COMMAND_SYNTAX_ERROR;
2666
2667 /* Original versions cared about the order of these tokens:
2668 * reset_config signals [combination [trst_type [srst_type]]]
2669 * They also clobbered the previous configuration even on error.
2670 *
2671 * Here we don't care about the order, and only change values
2672 * which have been explicitly specified.
2673 */
2674 for (; argc; argc--, args++) {
2675 int tmp = 0;
2676 int m;
2677
2678 /* signals */
2679 m = RESET_HAS_TRST | RESET_HAS_SRST;
2680 if (strcmp(*args, "none") == 0)
2681 tmp = RESET_NONE;
2682 else if (strcmp(*args, "trst_only") == 0)
2683 tmp = RESET_HAS_TRST;
2684 else if (strcmp(*args, "srst_only") == 0)
2685 tmp = RESET_HAS_SRST;
2686 else if (strcmp(*args, "trst_and_srst") == 0)
2687 tmp = RESET_HAS_TRST | RESET_HAS_SRST;
2688 else
2689 m = 0;
2690 if (mask & m) {
2691 LOG_ERROR("extra reset_config %s spec (%s)",
2692 "signal", *args);
2693 return ERROR_INVALID_ARGUMENTS;
2694 }
2695 if (m)
2696 goto next;
2697
2698 /* combination (options for broken wiring) */
2699 m = RESET_SRST_PULLS_TRST | RESET_TRST_PULLS_SRST;
2700 if (strcmp(*args, "separate") == 0)
2701 /* separate reset lines - default */;
2702 else if (strcmp(*args, "srst_pulls_trst") == 0)
2703 tmp |= RESET_SRST_PULLS_TRST;
2704 else if (strcmp(*args, "trst_pulls_srst") == 0)
2705 tmp |= RESET_TRST_PULLS_SRST;
2706 else if (strcmp(*args, "combined") == 0)
2707 tmp |= RESET_SRST_PULLS_TRST | RESET_TRST_PULLS_SRST;
2708 else
2709 m = 0;
2710 if (mask & m) {
2711 LOG_ERROR("extra reset_config %s spec (%s)",
2712 "combination", *args);
2713 return ERROR_INVALID_ARGUMENTS;
2714 }
2715 if (m)
2716 goto next;
2717
2718 /* trst_type (NOP without HAS_TRST) */
2719 m = RESET_TRST_OPEN_DRAIN;
2720 if (strcmp(*args, "trst_open_drain") == 0)
2721 tmp |= RESET_TRST_OPEN_DRAIN;
2722 else if (strcmp(*args, "trst_push_pull") == 0)
2723 /* push/pull from adapter - default */;
2724 else
2725 m = 0;
2726 if (mask & m) {
2727 LOG_ERROR("extra reset_config %s spec (%s)",
2728 "trst_type", *args);
2729 return ERROR_INVALID_ARGUMENTS;
2730 }
2731 if (m)
2732 goto next;
2733
2734 /* srst_type (NOP without HAS_SRST) */
2735 m |= RESET_SRST_PUSH_PULL;
2736 if (strcmp(*args, "srst_push_pull") == 0)
2737 tmp |= RESET_SRST_PUSH_PULL;
2738 else if (strcmp(*args, "srst_open_drain") == 0)
2739 /* open drain from adapter - default */;
2740 else
2741 m = 0;
2742 if (mask & m) {
2743 LOG_ERROR("extra reset_config %s spec (%s)",
2744 "srst_type", *args);
2745 return ERROR_INVALID_ARGUMENTS;
2746 }
2747 if (m)
2748 goto next;
2749
2750 /* caller provided nonsense; fail */
2751 LOG_ERROR("unknown reset_config flag (%s)", *args);
2752 return ERROR_INVALID_ARGUMENTS;
2753
2754 next:
2755 /* Remember the bits which were specified (mask)
2756 * and their new values (new_cfg).
2757 */
2758 mask |= m;
2759 new_cfg |= tmp;
2760 }
2761
2762 /* clear previous values of those bits, save new values */
2763 jtag_reset_config &= ~mask;
2764 jtag_reset_config |= new_cfg;
2765
2766 return ERROR_OK;
2767 }
2768
2769 static int handle_jtag_nsrst_delay_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2770 {
2771 if (argc < 1)
2772 {
2773 LOG_ERROR("jtag_nsrst_delay <ms> command takes one required argument");
2774 exit(-1);
2775 }
2776 else
2777 {
2778 jtag_nsrst_delay = strtoul(args[0], NULL, 0);
2779 }
2780
2781 return ERROR_OK;
2782 }
2783
2784 static int handle_jtag_ntrst_delay_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2785 {
2786 if (argc < 1)
2787 {
2788 LOG_ERROR("jtag_ntrst_delay <ms> command takes one required argument");
2789 exit(-1);
2790 }
2791 else
2792 {
2793 jtag_ntrst_delay = strtoul(args[0], NULL, 0);
2794 }
2795
2796 return ERROR_OK;
2797 }
2798
2799 static int handle_jtag_speed_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2800 {
2801 int retval=ERROR_OK;
2802
2803 if (argc == 1)
2804 {
2805 LOG_DEBUG("handle jtag speed");
2806
2807 int cur_speed = 0;
2808 cur_speed = jtag_speed = strtoul(args[0], NULL, 0);
2809
2810 /* this command can be called during CONFIG,
2811 * in which case jtag isn't initialized */
2812 if (jtag)
2813 {
2814 retval=jtag->speed(cur_speed);
2815 }
2816 } else if (argc == 0)
2817 {
2818 } else
2819 {
2820 return ERROR_COMMAND_SYNTAX_ERROR;
2821 }
2822 command_print(cmd_ctx, "jtag_speed: %d", jtag_speed);
2823
2824 return retval;
2825 }
2826
2827 static int handle_jtag_khz_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2828 {
2829 int retval=ERROR_OK;
2830 LOG_DEBUG("handle jtag khz");
2831
2832 if(argc == 1)
2833 {
2834 speed_khz = strtoul(args[0], NULL, 0);
2835 if (jtag != NULL)
2836 {
2837 int cur_speed = 0;
2838 LOG_DEBUG("have interface set up");
2839 int speed_div1;
2840 if ((retval=jtag->khz(speed_khz, &speed_div1))!=ERROR_OK)
2841 {
2842 speed_khz = 0;
2843 return retval;
2844 }
2845
2846 cur_speed = jtag_speed = speed_div1;
2847
2848 retval=jtag->speed(cur_speed);
2849 } else
2850 {
2851 hasKHz = 1;
2852 }
2853 } else if (argc==0)
2854 {
2855 } else
2856 {
2857 return ERROR_COMMAND_SYNTAX_ERROR;
2858 }
2859
2860 if (jtag!=NULL)
2861 {
2862 if ((retval=jtag->speed_div(jtag_speed, &speed_khz))!=ERROR_OK)
2863 return retval;
2864 }
2865
2866 if (speed_khz==0)
2867 {
2868 command_print(cmd_ctx, "RCLK - adaptive");
2869 } else
2870 {
2871 command_print(cmd_ctx, "%d kHz", speed_khz);
2872 }
2873 return retval;
2874
2875 }
2876
2877 static int handle_endstate_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2878 {
2879 tap_state_t state;
2880
2881 if (argc < 1)
2882 {
2883 return ERROR_COMMAND_SYNTAX_ERROR;
2884 }
2885 else
2886 {
2887 state = tap_state_by_name( args[0] );
2888 if( state < 0 ){
2889 command_print( cmd_ctx, "Invalid state name: %s\n", args[0] );
2890 return ERROR_COMMAND_SYNTAX_ERROR;
2891 }
2892 jtag_add_end_state(state);
2893 jtag_execute_queue();
2894 }
2895 command_print(cmd_ctx, "current endstate: %s", tap_state_name(cmd_queue_end_state));
2896
2897 return ERROR_OK;
2898 }
2899
2900 static int handle_jtag_reset_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2901 {
2902 int trst = -1;
2903 int srst = -1;
2904
2905 if (argc < 2)
2906 {
2907 return ERROR_COMMAND_SYNTAX_ERROR;
2908 }
2909
2910 if (args[0][0] == '1')
2911 trst = 1;
2912 else if (args[0][0] == '0')
2913 trst = 0;
2914 else
2915 {
2916 return ERROR_COMMAND_SYNTAX_ERROR;
2917 }
2918
2919 if (args[1][0] == '1')
2920 srst = 1;
2921 else if (args[1][0] == '0')
2922 srst = 0;
2923 else
2924 {
2925 return ERROR_COMMAND_SYNTAX_ERROR;
2926 }
2927
2928 if (jtag_interface_init(cmd_ctx) != ERROR_OK)
2929 return ERROR_JTAG_INIT_FAILED;
2930
2931 jtag_add_reset(trst, srst);
2932 jtag_execute_queue();
2933
2934 return ERROR_OK;
2935 }
2936
2937 static int handle_runtest_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2938 {
2939 if (argc < 1)
2940 {
2941 return ERROR_COMMAND_SYNTAX_ERROR;
2942 }
2943
2944 jtag_add_runtest(strtol(args[0], NULL, 0), TAP_INVALID);
2945 jtag_execute_queue();
2946
2947 return ERROR_OK;
2948
2949 }
2950
2951 /*
2952 * For "irscan" or "drscan" commands, the "end" (really, "next") state
2953 * should be stable ... and *NOT* a shift state, otherwise free-running
2954 * jtag clocks could change the values latched by the update state.
2955 */
2956 static bool scan_is_safe(tap_state_t state)
2957 {
2958 switch (state)
2959 {
2960 case TAP_RESET:
2961 case TAP_IDLE:
2962 case TAP_DRPAUSE:
2963 case TAP_IRPAUSE:
2964 return true;
2965 default:
2966 return false;
2967 }
2968 }
2969
2970
2971 static int handle_irscan_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2972 {
2973 int i;
2974 scan_field_t *fields;
2975 jtag_tap_t *tap;
2976 tap_state_t endstate;
2977
2978 if ((argc < 2) || (argc % 2))
2979 {
2980 return ERROR_COMMAND_SYNTAX_ERROR;
2981 }
2982
2983 /* optional "-endstate" "statename" at the end of the arguments,
2984 * so that e.g. IRPAUSE can let us load the data register before
2985 * entering RUN/IDLE to execute the instruction we load here.
2986 */
2987 endstate = TAP_IDLE;
2988
2989 if( argc >= 4 ){
2990 /* have at least one pair of numbers. */
2991 /* is last pair the magic text? */
2992 if( 0 == strcmp( "-endstate", args[ argc - 2 ] ) ){
2993 const char *cpA;
2994 const char *cpS;
2995 cpA = args[ argc-1 ];
2996 for( endstate = 0 ; endstate < TAP_NUM_STATES ; endstate++ ){
2997 cpS = tap_state_name( endstate );
2998 if( 0 == strcmp( cpA, cpS ) ){
2999 break;
3000 }
3001 }
3002 if( endstate >= TAP_NUM_STATES ){
3003 return ERROR_COMMAND_SYNTAX_ERROR;
3004 } else {
3005 if (!scan_is_safe(endstate))
3006 LOG_WARNING("irscan with unsafe "
3007 "endstate \"%s\"", cpA);
3008 /* found - remove the last 2 args */
3009 argc -= 2;
3010 }
3011 }
3012 }
3013
3014 int num_fields = argc / 2;
3015
3016 fields = malloc(sizeof(scan_field_t) * num_fields);
3017
3018 for (i = 0; i < num_fields; i++)
3019 {
3020 tap = jtag_TapByString( args[i*2] );
3021 if (tap==NULL)
3022 {
3023 command_print( cmd_ctx, "Tap: %s unknown", args[i*2] );
3024 return ERROR_FAIL;
3025 }
3026 int field_size = tap->ir_length;
3027 fields[i].tap = tap;
3028 fields[i].num_bits = field_size;
3029 fields[i].out_value = malloc(CEIL(field_size, 8));
3030 buf_set_u32(fields[i].out_value, 0, field_size, strtoul(args[i*2+1], NULL, 0));
3031 fields[i].in_value = NULL;
3032 }
3033
3034 /* did we have an endstate? */
3035 jtag_add_ir_scan(num_fields, fields, endstate);
3036
3037 int retval=jtag_execute_queue();
3038
3039 for (i = 0; i < num_fields; i++)
3040 free(fields[i].out_value);
3041
3042 free (fields);
3043
3044 return retval;
3045 }
3046
3047 static int Jim_Command_drscan(Jim_Interp *interp, int argc, Jim_Obj *const *args)
3048 {
3049 int retval;
3050 scan_field_t *fields;
3051 int num_fields;
3052 int field_count = 0;
3053 int i, e;
3054 jtag_tap_t *tap;
3055 tap_state_t endstate;
3056
3057 /* args[1] = device
3058 * args[2] = num_bits
3059 * args[3] = hex string
3060 * ... repeat num bits and hex string ...
3061 *
3062 * .. optionally:
3063 * args[N-2] = "-endstate"
3064 * args[N-1] = statename
3065 */
3066 if ((argc < 4) || ((argc % 2)!=0))
3067 {
3068 Jim_WrongNumArgs(interp, 1, args, "wrong arguments");
3069 return JIM_ERR;
3070 }
3071
3072 endstate = TAP_IDLE;
3073
3074 /* validate arguments as numbers */
3075 e = JIM_OK;
3076 for (i = 2; i < argc; i+=2)
3077 {
3078 long bits;
3079 const char *cp;
3080
3081 e = Jim_GetLong(interp, args[i], &bits);
3082 /* If valid - try next arg */
3083 if( e == JIM_OK ){
3084 continue;
3085 }
3086
3087 /* Not valid.. are we at the end? */
3088 if ( ((i+2) != argc) ){
3089 /* nope, then error */
3090 return e;
3091 }
3092
3093 /* it could be: "-endstate FOO"
3094 * e.g. DRPAUSE so we can issue more instructions
3095 * before entering RUN/IDLE and executing them.
3096 */
3097
3098 /* get arg as a string. */
3099 cp = Jim_GetString( args[i], NULL );
3100 /* is it the magic? */
3101 if( 0 == strcmp( "-endstate", cp ) ){
3102 /* is the statename valid? */
3103 cp = Jim_GetString( args[i+1], NULL );
3104
3105 /* see if it is a valid state name */
3106 endstate = tap_state_by_name(cp);
3107 if( endstate < 0 ){
3108 /* update the error message */
3109 Jim_SetResult_sprintf(interp,"endstate: %s invalid", cp );
3110 } else {
3111 if (!scan_is_safe(endstate))
3112 LOG_WARNING("drscan with unsafe "
3113 "endstate \"%s\"", cp);
3114
3115 /* valid - so clear the error */
3116 e = JIM_OK;
3117 /* and remove the last 2 args */
3118 argc -= 2;
3119 }
3120 }
3121
3122 /* Still an error? */
3123 if( e != JIM_OK ){
3124 return e; /* too bad */
3125 }
3126 } /* validate args */
3127
3128 tap = jtag_TapByJimObj( interp, args[1] );
3129 if( tap == NULL ){
3130 return JIM_ERR;
3131 }
3132
3133 num_fields=(argc-2)/2;
3134 fields = malloc(sizeof(scan_field_t) * num_fields);
3135 for (i = 2; i < argc; i+=2)
3136 {
3137 long bits;
3138 int len;
3139 const char *str;
3140
3141 Jim_GetLong(interp, args[i], &bits);
3142 str = Jim_GetString(args[i+1], &len);
3143
3144 fields[field_count].tap = tap;
3145 fields[field_count].num_bits = bits;
3146 fields[field_count].out_value = malloc(CEIL(bits, 8));
3147 str_to_buf(str, len, fields[field_count].out_value, bits, 0);
3148 fields[field_count].in_value = fields[field_count].out_value;
3149 field_count++;
3150 }
3151
3152 jtag_add_dr_scan(num_fields, fields, endstate);
3153
3154 retval = jtag_execute_queue();
3155 if (retval != ERROR_OK)
3156 {
3157 Jim_SetResultString(interp, "drscan: jtag execute failed",-1);
3158 return JIM_ERR;
3159 }
3160
3161 field_count=0;
3162 Jim_Obj *list = Jim_NewListObj(interp, NULL, 0);
3163 for (i = 2; i < argc; i+=2)
3164 {
3165 long bits;
3166 char *str;
3167
3168 Jim_GetLong(interp, args[i], &bits);
3169 str = buf_to_str(fields[field_count].in_value, bits, 16);
3170 free(fields[field_count].out_value);
3171
3172 Jim_ListAppendElement(interp, list, Jim_NewStringObj(interp, str, strlen(str)));
3173 free(str);
3174 field_count++;
3175 }
3176
3177 Jim_SetResult(interp, list);
3178
3179 free(fields);
3180
3181 return JIM_OK;
3182 }
3183
3184
3185 static int Jim_Command_flush_count(Jim_Interp *interp, int argc, Jim_Obj *const *args)
3186 {
3187 Jim_SetResult(interp, Jim_NewIntObj(interp, jtag_flush_queue_count));
3188
3189 return JIM_OK;
3190 }
3191
3192
3193 static int handle_verify_ircapture_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
3194 {
3195 if (argc == 1)
3196 {
3197 if (strcmp(args[0], "enable") == 0)
3198 {
3199 jtag_verify_capture_ir = 1;
3200 }
3201 else if (strcmp(args[0], "disable") == 0)
3202 {
3203 jtag_verify_capture_ir = 0;
3204 } else
3205 {
3206 return ERROR_COMMAND_SYNTAX_ERROR;
3207 }
3208 } else if (argc != 0)
3209 {
3210 return ERROR_COMMAND_SYNTAX_ERROR;
3211 }
3212
3213 command_print(cmd_ctx, "verify Capture-IR is %s", (jtag_verify_capture_ir) ? "enabled": "disabled");
3214
3215 return ERROR_OK;
3216 }
3217
3218 static int handle_verify_jtag_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
3219 {
3220 if (argc == 1)
3221 {
3222 if (strcmp(args[0], "enable") == 0)
3223 {
3224 jtag_verify = 1;
3225 }
3226 else if (strcmp(args[0], "disable") == 0)
3227 {
3228 jtag_verify = 0;
3229 } else
3230 {
3231 return ERROR_COMMAND_SYNTAX_ERROR;
3232 }
3233 } else if (argc != 0)
3234 {
3235 return ERROR_COMMAND_SYNTAX_ERROR;
3236 }
3237
3238 command_print(cmd_ctx, "verify jtag capture is %s", (jtag_verify) ? "enabled": "disabled");
3239
3240 return ERROR_OK;
3241 }
3242
3243
3244 int jtag_power_dropout(int *dropout)
3245 {
3246 return jtag->power_dropout(dropout);
3247 }
3248
3249 int jtag_srst_asserted(int *srst_asserted)
3250 {
3251 return jtag->srst_asserted(srst_asserted);
3252 }
3253
3254 void jtag_tap_handle_event( jtag_tap_t * tap, enum jtag_tap_event e)
3255 {
3256 jtag_tap_event_action_t * jteap;
3257 int done;
3258
3259 jteap = tap->event_action;
3260
3261 done = 0;
3262 while (jteap) {
3263 if (jteap->event == e) {
3264 done = 1;
3265 LOG_DEBUG( "JTAG tap: %s event: %d (%s) action: %s\n",
3266 tap->dotted_name,
3267 e,
3268 Jim_Nvp_value2name_simple(nvp_jtag_tap_event, e)->name,
3269 Jim_GetString(jteap->body, NULL) );
3270 if (Jim_EvalObj(interp, jteap->body) != JIM_OK) {
3271 Jim_PrintErrorMessage(interp);
3272 }
3273 }
3274
3275 jteap = jteap->next;
3276 }
3277
3278 if (!done) {
3279 LOG_DEBUG( "event %d %s - no action",
3280 e,
3281 Jim_Nvp_value2name_simple( nvp_jtag_tap_event, e)->name);
3282 }
3283 }
3284
3285 /*-----<Cable Helper API>---------------------------------------*/
3286
3287 /* these Cable Helper API functions are all documented in the jtag.h header file,
3288 using a Doxygen format. And since Doxygen's configuration file "Doxyfile",
3289 is setup to prefer its docs in the header file, no documentation is here, for
3290 if it were, it would have to be doubly maintained.
3291 */
3292
3293 /**
3294 * @see tap_set_state() and tap_get_state() accessors.
3295 * Actual name is not important since accessors hide it.
3296 */
3297 static tap_state_t state_follower = TAP_RESET;
3298
3299 void tap_set_state_impl( tap_state_t new_state )
3300 {
3301 /* this is the state we think the TAPs are in now, was cur_state */
3302 state_follower = new_state;
3303 }
3304
3305 tap_state_t tap_get_state()
3306 {
3307 return state_follower;
3308 }
3309
3310 /**
3311 * @see tap_set_end_state() and tap_get_end_state() accessors.
3312 * Actual name is not important because accessors hide it.
3313 */
3314 static tap_state_t end_state_follower = TAP_RESET;
3315
3316 void tap_set_end_state( tap_state_t new_end_state )
3317 {
3318 /* this is the state we think the TAPs will be in at completion of the
3319 current TAP operation, was end_state
3320 */
3321 end_state_follower = new_end_state;
3322 }
3323
3324 tap_state_t tap_get_end_state()
3325 {
3326 return end_state_follower;
3327 }
3328
3329
3330 int tap_move_ndx( tap_state_t astate )
3331 {
3332 /* given a stable state, return the index into the tms_seqs[] array within tap_get_tms_path() */
3333
3334 int ndx;
3335
3336 switch( astate )
3337 {
3338 case TAP_RESET: ndx = 0; break;
3339 case TAP_DRSHIFT: ndx = 2; break;
3340 case TAP_DRPAUSE: ndx = 3; break;
3341 case TAP_IDLE: ndx = 1; break;
3342 case TAP_IRSHIFT: ndx = 4; break;
3343 case TAP_IRPAUSE: ndx = 5; break;
3344 default:
3345 LOG_ERROR( "fatal: unstable state \"%s\" used in tap_move_ndx()", tap_state_name(astate) );
3346 exit(1);
3347 }
3348
3349 return ndx;
3350 }
3351
3352
3353 /* tap_move[i][j]: tap movement command to go from state i to state j
3354 * 0: Test-Logic-Reset
3355 * 1: Run-Test/Idle
3356 * 2: Shift-DR
3357 * 3: Pause-DR
3358 * 4: Shift-IR
3359 * 5: Pause-IR
3360 *
3361 * DRSHIFT->DRSHIFT and IRSHIFT->IRSHIFT have to be caught in interface specific code
3362 */
3363 struct tms_sequences
3364 {
3365 u8 bits;
3366 u8 bit_count;
3367
3368 };
3369
3370 /*
3371 * These macros allow us to specify TMS state transitions by bits rather than hex bytes.
3372 * Read the bits from LSBit first to MSBit last (right-to-left).
3373 */
3374 #define HEX__(n) 0x##n##LU
3375
3376 #define B8__(x) \
3377 (((x) & 0x0000000FLU)?(1<<0):0) \
3378 +(((x) & 0x000000F0LU)?(1<<1):0) \
3379 +(((x) & 0x00000F00LU)?(1<<2):0) \
3380 +(((x) & 0x0000F000LU)?(1<<3):0) \
3381 +(((x) & 0x000F0000LU)?(1<<4):0) \
3382 +(((x) & 0x00F00000LU)?(1<<5):0) \
3383 +(((x) & 0x0F000000LU)?(1<<6):0) \
3384 +(((x) & 0xF0000000LU)?(1<<7):0)
3385
3386 #define B8(bits,count) { ((u8)B8__(HEX__(bits))), (count) }
3387
3388 static const struct tms_sequences old_tms_seqs[6][6] = /* [from_state_ndx][to_state_ndx] */
3389 {
3390 /* value clocked to TMS to move from one of six stable states to another.
3391 * N.B. OOCD clocks TMS from LSB first, so read these right-to-left.
3392 * N.B. These values are tightly bound to the table in tap_get_tms_path_len().
3393 * N.B. Reset only needs to be 0b11111, but in JLink an even byte of 1's is more stable.
3394 * These extra ones cause no TAP state problem, because we go into reset and stay in reset.
3395 */
3396
3397
3398
3399 /* to state: */
3400 /* RESET IDLE DRSHIFT DRPAUSE IRSHIFT IRPAUSE */ /* from state: */
3401 { B8(1111111,7), B8(0000000,7), B8(0010111,7), B8(0001010,7), B8(0011011,7), B8(0010110,7) }, /* RESET */
3402 { B8(1111111,7), B8(0000000,7), B8(0100101,7), B8(0000101,7), B8(0101011,7), B8(0001011,7) }, /* IDLE */
3403 { B8(1111111,7), B8(0110001,7), B8(0000000,7), B8(0000001,7), B8(0001111,7), B8(0101111,7) }, /* DRSHIFT */
3404 { B8(1111111,7), B8(0110000,7), B8(0100000,7), B8(0010111,7), B8(0011110,7), B8(0101111,7) }, /* DRPAUSE */
3405 { B8(1111111,7), B8(0110001,7), B8(0000111,7), B8(0010111,7), B8(0000000,7), B8(0000001,7) }, /* IRSHIFT */
3406 { B8(1111111,7), B8(0110000,7), B8(0011100,7), B8(0010111,7), B8(0011110,7), B8(0101111,7) }, /* IRPAUSE */
3407 };
3408
3409
3410
3411 static const struct tms_sequences short_tms_seqs[6][6] = /* [from_state_ndx][to_state_ndx] */
3412 {
3413 /* this is the table submitted by Jeff Williams on 3/30/2009 with this comment:
3414
3415 OK, I added Peter's version of the state table, and it works OK for
3416 me on MC1322x. I've recreated the jlink portion of patch with this
3417 new state table. His changes to my state table are pretty minor in
3418 terms of total transitions, but Peter feels that his version fixes
3419 some long-standing problems.
3420 Jeff
3421
3422 I added the bit count into the table, reduced RESET column to 7 bits from 8.
3423 Dick
3424
3425 state specific comments:
3426 ------------------------
3427 *->RESET tried the 5 bit reset and it gave me problems, 7 bits seems to
3428 work better on ARM9 with ft2232 driver. (Dick)
3429
3430 RESET->DRSHIFT add 1 extra clock cycles in the RESET state before advancing.
3431 needed on ARM9 with ft2232 driver. (Dick)
3432
3433 RESET->IRSHIFT add 1 extra clock cycles in the RESET state before advancing.
3434 needed on ARM9 with ft2232 driver. (Dick)
3435 */
3436
3437 /* to state: */
3438 /* RESET IDLE DRSHIFT DRPAUSE IRSHIFT IRPAUSE */ /* from state: */
3439 { B8(1111111,7), B8(0000000,7), B8(0010111,7), B8(0001010,7), B8(0011011,7), B8(0010110,7) }, /* RESET */
3440 { B8(1111111,7), B8(0000000,7), B8(001,3), B8(0101,4), B8(0011,4), B8(01011,5) }, /* IDLE */
3441 { B8(1111111,7), B8(011,3), B8(00111,5), B8(01,2), B8(001111,6), B8(0101111,7) }, /* DRSHIFT */
3442 { B8(1111111,7), B8(011,3), B8(01,2), B8(0,1), B8(001111,6), B8(0101111,7) }, /* DRPAUSE */
3443 { B8(1111111,7), B8(011,3), B8(00111,5), B8(010111,6), B8(001111,6), B8(01,2) }, /* IRSHIFT */
3444 { B8(1111111,7), B8(011,3), B8(00111,5), B8(010111,6), B8(01,2), B8(0,1) } /* IRPAUSE */
3445
3446 };
3447
3448 typedef const struct tms_sequences tms_table[6][6];
3449
3450 static tms_table *tms_seqs=&short_tms_seqs;
3451
3452 int tap_get_tms_path( tap_state_t from, tap_state_t to )
3453 {
3454 return (*tms_seqs)[tap_move_ndx(from)][tap_move_ndx(to)].bits;
3455 }
3456
3457
3458 int tap_get_tms_path_len( tap_state_t from, tap_state_t to )
3459 {
3460 return (*tms_seqs)[tap_move_ndx(from)][tap_move_ndx(to)].bit_count;
3461 }
3462
3463
3464 bool tap_is_state_stable(tap_state_t astate)
3465 {
3466 bool is_stable;
3467
3468 /* A switch() is used because it is symbol dependent
3469 (not value dependent like an array), and can also check bounds.
3470 */
3471 switch( astate )
3472 {
3473 case TAP_RESET:
3474 case TAP_IDLE:
3475 case TAP_DRSHIFT:
3476 case TAP_DRPAUSE:
3477 case TAP_IRSHIFT:
3478 case TAP_IRPAUSE:
3479 is_stable = true;
3480 break;
3481 default:
3482 is_stable = false;
3483 }
3484
3485 return is_stable;
3486 }
3487
3488 tap_state_t tap_state_transition(tap_state_t cur_state, bool tms)
3489 {
3490 tap_state_t new_state;
3491
3492 /* A switch is used because it is symbol dependent and not value dependent
3493 like an array. Also it can check for out of range conditions.
3494 */
3495
3496 if (tms)
3497 {
3498 switch (cur_state)
3499 {
3500 case TAP_RESET:
3501 new_state = cur_state;
3502 break;
3503 case TAP_IDLE:
3504 case TAP_DRUPDATE:
3505 case TAP_IRUPDATE:
3506 new_state = TAP_DRSELECT;
3507 break;
3508 case TAP_DRSELECT:
3509 new_state = TAP_IRSELECT;
3510 break;
3511 case TAP_DRCAPTURE:
3512 case TAP_DRSHIFT:
3513 new_state = TAP_DREXIT1;
3514 break;
3515 case TAP_DREXIT1:
3516 case TAP_DREXIT2:
3517 new_state = TAP_DRUPDATE;
3518 break;
3519 case TAP_DRPAUSE:
3520 new_state = TAP_DREXIT2;
3521 break;
3522 case TAP_IRSELECT:
3523 new_state = TAP_RESET;
3524 break;
3525 case TAP_IRCAPTURE:
3526 case TAP_IRSHIFT:
3527 new_state = TAP_IREXIT1;
3528 break;
3529 case TAP_IREXIT1:
3530 case TAP_IREXIT2:
3531 new_state = TAP_IRUPDATE;
3532 break;
3533 case TAP_IRPAUSE:
3534 new_state = TAP_IREXIT2;
3535 break;
3536 default:
3537 LOG_ERROR( "fatal: invalid argument cur_state=%d", cur_state );
3538 exit(1);
3539 break;
3540 }
3541 }
3542 else
3543 {
3544 switch (cur_state)
3545 {
3546 case TAP_RESET:
3547 case TAP_IDLE:
3548 case TAP_DRUPDATE:
3549 case TAP_IRUPDATE:
3550 new_state = TAP_IDLE;
3551 break;
3552 case TAP_DRSELECT:
3553 new_state = TAP_DRCAPTURE;
3554 break;
3555 case TAP_DRCAPTURE:
3556 case TAP_DRSHIFT:
3557 case TAP_DREXIT2:
3558 new_state = TAP_DRSHIFT;
3559 break;
3560 case TAP_DREXIT1:
3561 case TAP_DRPAUSE:
3562 new_state = TAP_DRPAUSE;
3563 break;
3564 case TAP_IRSELECT:
3565 new_state = TAP_IRCAPTURE;
3566 break;
3567 case TAP_IRCAPTURE:
3568 case TAP_IRSHIFT:
3569 case TAP_IREXIT2:
3570 new_state = TAP_IRSHIFT;
3571 break;
3572 case TAP_IREXIT1:
3573 case TAP_IRPAUSE:
3574 new_state = TAP_IRPAUSE;
3575 break;
3576 default:
3577 LOG_ERROR( "fatal: invalid argument cur_state=%d", cur_state );
3578 exit(1);
3579 break;
3580 }
3581 }
3582
3583 return new_state;
3584 }
3585
3586 const char* tap_state_name(tap_state_t state)
3587 {
3588 const char* ret;
3589
3590 switch( state )
3591 {
3592 case TAP_RESET: ret = "RESET"; break;
3593 case TAP_IDLE: ret = "RUN/IDLE"; break;
3594 case TAP_DRSELECT: ret = "DRSELECT"; break;
3595 case TAP_DRCAPTURE: ret = "DRCAPTURE"; break;
3596 case TAP_DRSHIFT: ret = "DRSHIFT"; break;
3597 case TAP_DREXIT1: ret = "DREXIT1"; break;
3598 case TAP_DRPAUSE: ret = "DRPAUSE"; break;
3599 case TAP_DREXIT2: ret = "DREXIT2"; break;
3600 case TAP_DRUPDATE: ret = "DRUPDATE"; break;
3601 case TAP_IRSELECT: ret = "IRSELECT"; break;
3602 case TAP_IRCAPTURE: ret = "IRCAPTURE"; break;
3603 case TAP_IRSHIFT: ret = "IRSHIFT"; break;
3604 case TAP_IREXIT1: ret = "IREXIT1"; break;
3605 case TAP_IRPAUSE: ret = "IRPAUSE"; break;
3606 case TAP_IREXIT2: ret = "IREXIT2"; break;
3607 case TAP_IRUPDATE: ret = "IRUPDATE"; break;
3608 default: ret = "???";
3609 }
3610
3611 return ret;
3612 }
3613
3614 static tap_state_t tap_state_by_name( const char *name )
3615 {
3616 tap_state_t x;
3617
3618 for( x = 0 ; x < TAP_NUM_STATES ; x++ ){
3619 /* be nice to the human */
3620 if( 0 == strcasecmp( name, tap_state_name(x) ) ){
3621 return x;
3622 }
3623 }
3624 /* not found */
3625 return TAP_INVALID;
3626 }
3627
3628 #ifdef _DEBUG_JTAG_IO_
3629
3630 #define JTAG_DEBUG_STATE_APPEND(buf, len, bit) \
3631 do { buf[len] = bit ? '1' : '0'; } while(0)
3632 #define JTAG_DEBUG_STATE_PRINT(a, b, astr, bstr) \
3633 DEBUG_JTAG_IO("TAP/SM: %9s -> %5s\tTMS: %s\tTDI: %s", \
3634 tap_state_name(a), tap_state_name(b), astr, bstr)
3635
3636 tap_state_t jtag_debug_state_machine(const void *tms_buf, const void *tdi_buf,
3637 unsigned tap_bits, tap_state_t next_state)
3638 {
3639 const u8 *tms_buffer;
3640 const u8 *tdi_buffer;
3641 unsigned tap_bytes;
3642 unsigned cur_byte;
3643 unsigned cur_bit;
3644
3645 unsigned tap_out_bits;
3646 char tms_str[33];
3647 char tdi_str[33];
3648
3649 tap_state_t last_state;
3650
3651 // set startstate (and possibly last, if tap_bits == 0)
3652 last_state = next_state;
3653 DEBUG_JTAG_IO("TAP/SM: START state: %s", tap_state_name(next_state));
3654
3655 tms_buffer = (const u8 *)tms_buf;
3656 tdi_buffer = (const u8 *)tdi_buf;
3657
3658 tap_bytes = TAP_SCAN_BYTES(tap_bits);
3659 DEBUG_JTAG_IO("TAP/SM: TMS bits: %u (bytes: %u)", tap_bits, tap_bytes);
3660
3661 tap_out_bits = 0;
3662 for(cur_byte = 0; cur_byte < tap_bytes; cur_byte++)
3663 {
3664 for(cur_bit = 0; cur_bit < 8; cur_bit++)
3665 {
3666 // make sure we do not run off the end of the buffers
3667 unsigned tap_bit = cur_byte * 8 + cur_bit;
3668 if (tap_bit == tap_bits)
3669 break;
3670
3671 // check and save TMS bit
3672 tap_bit = !!(tms_buffer[cur_byte] & (1 << cur_bit));
3673 JTAG_DEBUG_STATE_APPEND(tms_str, tap_out_bits, tap_bit);
3674
3675 // use TMS bit to find the next TAP state
3676 next_state = tap_state_transition(last_state, tap_bit);
3677
3678 // check and store TDI bit
3679 tap_bit = !!(tdi_buffer[cur_byte] & (1 << cur_bit));
3680 JTAG_DEBUG_STATE_APPEND(tdi_str, tap_out_bits, tap_bit);
3681
3682 // increment TAP bits
3683 tap_out_bits++;
3684
3685 // Only show TDO bits on state transitions, or
3686 // after some number of bits in the same state.
3687 if ((next_state == last_state) && (tap_out_bits < 32))
3688 continue;
3689
3690 // terminate strings and display state transition
3691 tms_str[tap_out_bits] = tdi_str[tap_out_bits] = 0;
3692 JTAG_DEBUG_STATE_PRINT(last_state, next_state, tms_str, tdi_str);
3693
3694 // reset state
3695 last_state = next_state;
3696 tap_out_bits = 0;
3697 }
3698 }
3699
3700 if (tap_out_bits)
3701 {
3702 // terminate strings and display state transition
3703 tms_str[tap_out_bits] = tdi_str[tap_out_bits] = 0;
3704 JTAG_DEBUG_STATE_PRINT(last_state, next_state, tms_str, tdi_str);
3705 }
3706
3707 DEBUG_JTAG_IO("TAP/SM: FINAL state: %s", tap_state_name(next_state));
3708
3709 return next_state;
3710 }
3711 #endif // _DEBUG_JTAG_IO_
3712
3713 #ifndef HAVE_JTAG_MINIDRIVER_H
3714 void jtag_alloc_in_value32(scan_field_t *field)
3715 {
3716 field->in_value=(u8 *)cmd_queue_alloc(4);
3717 }
3718 #endif
3719
3720 static int handle_tms_sequence_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
3721 {
3722 if (argc == 1)
3723 {
3724 if (strcmp(args[0], "short") == 0)
3725 {
3726 tms_seqs=&short_tms_seqs;
3727 }
3728 else if (strcmp(args[0], "long") == 0)
3729 {
3730 tms_seqs=&old_tms_seqs;
3731 } else
3732 {
3733 return ERROR_COMMAND_SYNTAX_ERROR;
3734 }
3735 } else if (argc != 0)
3736 {
3737 return ERROR_COMMAND_SYNTAX_ERROR;
3738 }
3739
3740 command_print(cmd_ctx, "tms sequence is %s", (tms_seqs==&short_tms_seqs) ? "short": "long");
3741
3742 return ERROR_OK;
3743 }
3744
3745 /*-----</Cable Helper API>--------------------------------------*/
3746
3747
3748 /**
3749 * Function jtag_add_statemove
3750 * moves from the current state to the goal \a state. This needs
3751 * to be handled according to the xsvf spec, see the XSTATE command
3752 * description.
3753 */
3754 int jtag_add_statemove(tap_state_t goal_state)
3755 {
3756 int retval = ERROR_OK;
3757
3758 tap_state_t moves[8];
3759 tap_state_t cur_state = cmd_queue_cur_state;
3760 int i;
3761 int tms_bits;
3762 int tms_count;
3763
3764 LOG_DEBUG( "cur_state=%s goal_state=%s",
3765 tap_state_name(cur_state),
3766 tap_state_name(goal_state) );
3767
3768
3769 /* From the XSVF spec, pertaining to XSTATE:
3770
3771 For special states known as stable states (Test-Logic-Reset,
3772 Run-Test/Idle, Pause-DR, Pause- IR), an XSVF interpreter follows
3773 predefined TAP state paths when the starting state is a stable state and
3774 when the XSTATE specifies a new stable state (see the STATE command in
3775 the [Ref 5] for the TAP state paths between stable states). For
3776 non-stable states, XSTATE should specify a state that is only one TAP
3777 state transition distance from the current TAP state to avoid undefined
3778 TAP state paths. A sequence of multiple XSTATE commands can be issued to
3779 transition the TAP through a specific state path.
3780 */
3781
3782 if (goal_state==cur_state )
3783 ; /* nothing to do */
3784
3785 else if( goal_state==TAP_RESET )
3786 {
3787 jtag_add_tlr();
3788 }
3789
3790 else if( tap_is_state_stable(cur_state) && tap_is_state_stable(goal_state) )
3791 {
3792 /* note: unless tms_bits holds a path that agrees with [Ref 5] in above
3793 spec, then this code is not fully conformant to the xsvf spec. This
3794 puts a burden on tap_get_tms_path() function from the xsvf spec.
3795 If in doubt, you should confirm that that burden is being met.
3796 */
3797
3798 tms_bits = tap_get_tms_path(cur_state, goal_state);
3799 tms_count = tap_get_tms_path_len(cur_state, goal_state);
3800
3801 assert( (unsigned) tms_count < DIM(moves) );
3802
3803 for (i=0; i<tms_count; i++, tms_bits>>=1)
3804 {
3805 bool bit = tms_bits & 1;
3806
3807 cur_state = tap_state_transition(cur_state, bit);
3808 moves[i] = cur_state;
3809 }
3810
3811 jtag_add_pathmove(tms_count, moves);
3812 }
3813
3814 /* else state must be immediately reachable in one clock cycle, and does not
3815 need to be a stable state.
3816 */
3817 else if( tap_state_transition(cur_state, true) == goal_state
3818 || tap_state_transition(cur_state, false) == goal_state )
3819 {
3820 /* move a single state */
3821 moves[0] = goal_state;
3822 jtag_add_pathmove( 1, moves );
3823 }
3824
3825 else
3826 {
3827 retval = ERROR_FAIL;
3828 }
3829
3830 return retval;
3831 }
3832
Open On-Chip Debugger

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)