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