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