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