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