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