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