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