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

Linking to existing account procedure

If you already have an account and want to add another login method you MUST first sign in with your existing account and then change URL to read https://review.openocd.org/login/?link to get to this page again but this time it'll work for linking. Thank you.

SSH host keys fingerprints

1024 SHA256:YKx8b7u5ZWdcbp7/4AeXNaqElP49m6QrwfXaqQGJAOk gerrit-code-review@openocd.zylin.com (DSA)
384 SHA256:jHIbSQa4REvwCFG4cq5LBlBLxmxSqelQPem/EXIrxjk gerrit-code-review@openocd.org (ECDSA)
521 SHA256:UAOPYkU9Fjtcao0Ul/Rrlnj/OsQvt+pgdYSZ4jOYdgs gerrit-code-review@openocd.org (ECDSA)
256 SHA256:A13M5QlnozFOvTllybRZH6vm7iSt0XLxbA48yfc2yfY gerrit-code-review@openocd.org (ECDSA)
256 SHA256:spYMBqEYoAOtK7yZBrcwE8ZpYt6b68Cfh9yEVetvbXg gerrit-code-review@openocd.org (ED25519)
+--[ED25519 256]--+
|=..              |
|+o..   .         |
|*.o   . .        |
|+B . . .         |
|Bo. = o S        |
|Oo.+ + =         |
|oB=.* = . o      |
| =+=.+   + E     |
|. .=o   . o      |
+----[SHA256]-----+
2048 SHA256:0Onrb7/PHjpo6iVZ7xQX2riKN83FJ3KGU0TvI0TaFG4 gerrit-code-review@openocd.zylin.com (RSA)