Code Review / openocd.git / blob
? search:


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