Code Review / openocd.git / blob
? search:
summary | shortlog | log | commit | commitdiff | review | tree
history | raw | HEAD
xvsf player fixes by 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 * 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 /* "if (tap_move_map[cm_queue_cur_state] != -1)" is of no help when cur_state==TAP_IDLE */
1097 switch(cmd_queue_cur_state)
1098 {
1099 case TAP_DRSHIFT:
1100 case TAP_IDLE:
1101 case TAP_RESET:
1102 case TAP_DRPAUSE:
1103 case TAP_IRSHIFT:
1104 case TAP_IRPAUSE:
1105 break; /* above stable states are OK */
1106 default:
1107 LOG_ERROR( "jtag_add_clocks() was called with TAP in non-stable state \"%s\"",
1108 jtag_state_name(cmd_queue_cur_state) );
1109 jtag_error = ERROR_JTAG_NOT_STABLE_STATE;
1110 return;
1111 }
1112
1113 if( num_cycles > 0 )
1114 {
1115 jtag_prelude1();
1116
1117 retval=interface_jtag_add_clocks(num_cycles);
1118 if (retval!=ERROR_OK)
1119 jtag_error=retval;
1120 }
1121 }
1122
1123 void jtag_add_reset(int req_tlr_or_trst, int req_srst)
1124 {
1125 int trst_with_tlr = 0;
1126 int retval;
1127
1128 /* FIX!!! there are *many* different cases here. A better
1129 * approach is needed for legal combinations of transitions...
1130 */
1131 if ((jtag_reset_config & RESET_HAS_SRST)&&
1132 (jtag_reset_config & RESET_HAS_TRST)&&
1133 ((jtag_reset_config & RESET_SRST_PULLS_TRST)==0))
1134 {
1135 if (((req_tlr_or_trst&&!jtag_trst)||
1136 (!req_tlr_or_trst&&jtag_trst))&&
1137 ((req_srst&&!jtag_srst)||
1138 (!req_srst&&jtag_srst)))
1139 {
1140 /* FIX!!! srst_pulls_trst allows 1,1 => 0,0 transition.... */
1141 //LOG_ERROR("BUG: transition of req_tlr_or_trst and req_srst in the same jtag_add_reset() call is undefined");
1142 }
1143 }
1144
1145 /* Make sure that jtag_reset_config allows the requested reset */
1146 /* if SRST pulls TRST, we can't fulfill srst == 1 with trst == 0 */
1147 if (((jtag_reset_config & RESET_SRST_PULLS_TRST) && (req_srst == 1)) && (!req_tlr_or_trst))
1148 {
1149 LOG_ERROR("BUG: requested reset would assert trst");
1150 jtag_error=ERROR_FAIL;
1151 return;
1152 }
1153
1154 /* if TRST pulls SRST, we reset with TAP T-L-R */
1155 if (((jtag_reset_config & RESET_TRST_PULLS_SRST) && (req_tlr_or_trst)) && (req_srst == 0))
1156 {
1157 trst_with_tlr = 1;
1158 }
1159
1160 if (req_srst && !(jtag_reset_config & RESET_HAS_SRST))
1161 {
1162 LOG_ERROR("BUG: requested SRST assertion, but the current configuration doesn't support this");
1163 jtag_error=ERROR_FAIL;
1164 return;
1165 }
1166
1167 if (req_tlr_or_trst)
1168 {
1169 if (!trst_with_tlr && (jtag_reset_config & RESET_HAS_TRST))
1170 {
1171 jtag_trst = 1;
1172 } else
1173 {
1174 trst_with_tlr = 1;
1175 }
1176 } else
1177 {
1178 jtag_trst = 0;
1179 }
1180
1181 jtag_srst = req_srst;
1182
1183 retval = interface_jtag_add_reset(jtag_trst, jtag_srst);
1184 if (retval!=ERROR_OK)
1185 {
1186 jtag_error=retval;
1187 return;
1188 }
1189
1190 if (jtag_srst)
1191 {
1192 LOG_DEBUG("SRST line asserted");
1193 }
1194 else
1195 {
1196 LOG_DEBUG("SRST line released");
1197 if (jtag_nsrst_delay)
1198 jtag_add_sleep(jtag_nsrst_delay * 1000);
1199 }
1200
1201 if (trst_with_tlr)
1202 {
1203 LOG_DEBUG("JTAG reset with RESET instead of TRST");
1204 jtag_add_end_state(TAP_RESET);
1205 jtag_add_tlr();
1206 jtag_call_event_callbacks(JTAG_TRST_ASSERTED);
1207 return;
1208 }
1209
1210 if (jtag_trst)
1211 {
1212 /* we just asserted nTRST, so we're now in Test-Logic-Reset,
1213 * and inform possible listeners about this
1214 */
1215 LOG_DEBUG("TRST line asserted");
1216 cmd_queue_cur_state = TAP_RESET;
1217 jtag_call_event_callbacks(JTAG_TRST_ASSERTED);
1218 }
1219 else
1220 {
1221 if (jtag_ntrst_delay)
1222 jtag_add_sleep(jtag_ntrst_delay * 1000);
1223 }
1224 }
1225
1226 int MINIDRIVER(interface_jtag_add_reset)(int req_trst, int req_srst)
1227 {
1228 jtag_command_t **last_cmd = jtag_get_last_command_p();
1229
1230 /* allocate memory for a new list member */
1231 *last_cmd = cmd_queue_alloc(sizeof(jtag_command_t));
1232 (*last_cmd)->next = NULL;
1233 last_comand_pointer = &((*last_cmd)->next);
1234 (*last_cmd)->type = JTAG_RESET;
1235
1236 (*last_cmd)->cmd.reset = cmd_queue_alloc(sizeof(reset_command_t));
1237 (*last_cmd)->cmd.reset->trst = req_trst;
1238 (*last_cmd)->cmd.reset->srst = req_srst;
1239
1240 return ERROR_OK;
1241 }
1242
1243 void jtag_add_end_state(enum tap_state state)
1244 {
1245 cmd_queue_end_state = state;
1246 if ((cmd_queue_end_state == TAP_DRSHIFT)||(cmd_queue_end_state == TAP_IRSHIFT))
1247 {
1248 LOG_ERROR("BUG: TAP_DRSHIFT/IRSHIFT can't be end state. Calling code should use a larger scan field");
1249 }
1250 }
1251
1252 int MINIDRIVER(interface_jtag_add_sleep)(u32 us)
1253 {
1254 jtag_command_t **last_cmd = jtag_get_last_command_p();
1255
1256 /* allocate memory for a new list member */
1257 *last_cmd = cmd_queue_alloc(sizeof(jtag_command_t));
1258 (*last_cmd)->next = NULL;
1259 last_comand_pointer = &((*last_cmd)->next);
1260 (*last_cmd)->type = JTAG_SLEEP;
1261
1262 (*last_cmd)->cmd.sleep = cmd_queue_alloc(sizeof(sleep_command_t));
1263 (*last_cmd)->cmd.sleep->us = us;
1264
1265 return ERROR_OK;
1266 }
1267
1268 void jtag_add_sleep(u32 us)
1269 {
1270 keep_alive(); /* we might be running on a very slow JTAG clk */
1271 int retval=interface_jtag_add_sleep(us);
1272 if (retval!=ERROR_OK)
1273 jtag_error=retval;
1274 return;
1275 }
1276
1277 int jtag_scan_size(scan_command_t *cmd)
1278 {
1279 int bit_count = 0;
1280 int i;
1281
1282 /* count bits in scan command */
1283 for (i = 0; i < cmd->num_fields; i++)
1284 {
1285 bit_count += cmd->fields[i].num_bits;
1286 }
1287
1288 return bit_count;
1289 }
1290
1291 int jtag_build_buffer(scan_command_t *cmd, u8 **buffer)
1292 {
1293 int bit_count = 0;
1294 int i;
1295
1296 bit_count = jtag_scan_size(cmd);
1297 *buffer = malloc(CEIL(bit_count, 8));
1298
1299 bit_count = 0;
1300
1301 #ifdef _DEBUG_JTAG_IO_
1302 LOG_DEBUG("num_fields: %i",cmd->num_fields);
1303 #endif
1304
1305 for (i = 0; i < cmd->num_fields; i++)
1306 {
1307 if (cmd->fields[i].out_value)
1308 {
1309 #ifdef _DEBUG_JTAG_IO_
1310 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);
1311 #endif
1312 buf_set_buf(cmd->fields[i].out_value, 0, *buffer, bit_count, cmd->fields[i].num_bits);
1313 #ifdef _DEBUG_JTAG_IO_
1314 LOG_DEBUG("fields[%i].out_value[%i]: 0x%s", i, cmd->fields[i].num_bits, char_buf);
1315 free(char_buf);
1316 #endif
1317 }
1318
1319 bit_count += cmd->fields[i].num_bits;
1320 }
1321
1322 return bit_count;
1323 }
1324
1325 int jtag_read_buffer(u8 *buffer, scan_command_t *cmd)
1326 {
1327 int i;
1328 int bit_count = 0;
1329 int retval;
1330
1331 /* we return ERROR_OK, unless a check fails, or a handler reports a problem */
1332 retval = ERROR_OK;
1333
1334 for (i = 0; i < cmd->num_fields; i++)
1335 {
1336 /* if neither in_value nor in_handler
1337 * are specified we don't have to examine this field
1338 */
1339 if (cmd->fields[i].in_value || cmd->fields[i].in_handler)
1340 {
1341 int num_bits = cmd->fields[i].num_bits;
1342 u8 *captured = buf_set_buf(buffer, bit_count, malloc(CEIL(num_bits, 8)), 0, num_bits);
1343
1344 #ifdef _DEBUG_JTAG_IO_
1345 char *char_buf = buf_to_str(captured, (num_bits > DEBUG_JTAG_IOZ) ? DEBUG_JTAG_IOZ : num_bits, 16);
1346 LOG_DEBUG("fields[%i].in_value[%i]: 0x%s", i, num_bits, char_buf);
1347 free(char_buf);
1348 #endif
1349
1350 if (cmd->fields[i].in_value)
1351 {
1352 buf_cpy(captured, cmd->fields[i].in_value, num_bits);
1353
1354 if (cmd->fields[i].in_handler)
1355 {
1356 if (cmd->fields[i].in_handler(cmd->fields[i].in_value, cmd->fields[i].in_handler_priv, cmd->fields+i) != ERROR_OK)
1357 {
1358 LOG_WARNING("in_handler: with \"in_value\", mismatch in %s", cmd->ir_scan ? "SIR" : "SDR" );
1359 retval = ERROR_JTAG_QUEUE_FAILED;
1360 }
1361 }
1362 }
1363
1364 /* no in_value specified, but a handler takes care of the scanned data */
1365 if (cmd->fields[i].in_handler && (!cmd->fields[i].in_value))
1366 {
1367 if (cmd->fields[i].in_handler(captured, cmd->fields[i].in_handler_priv, cmd->fields+i) != ERROR_OK)
1368 {
1369 /* We're going to call the error:handler later, but if the in_handler
1370 * reported an error we report this failure upstream
1371 */
1372 LOG_WARNING("in_handler: w/o \"in_value\", mismatch in %s", cmd->ir_scan ? "SIR" : "SDR" );
1373 retval = ERROR_JTAG_QUEUE_FAILED;
1374 }
1375 }
1376
1377 free(captured);
1378 }
1379 bit_count += cmd->fields[i].num_bits;
1380 }
1381
1382 return retval;
1383 }
1384
1385 static const char *jtag_tap_name(jtag_tap_t *tap)
1386 {
1387 return (tap == NULL) ? "(unknown)" : tap->dotted_name;
1388 }
1389
1390 int jtag_check_value(u8 *captured, void *priv, scan_field_t *field)
1391 {
1392 int retval = ERROR_OK;
1393 int num_bits = field->num_bits;
1394
1395 int compare_failed = 0;
1396
1397 if (field->in_check_mask)
1398 compare_failed = buf_cmp_mask(captured, field->in_check_value, field->in_check_mask, num_bits);
1399 else
1400 compare_failed = buf_cmp(captured, field->in_check_value, num_bits);
1401
1402 if (compare_failed){
1403 /* An error handler could have caught the failing check
1404 * only report a problem when there wasn't a handler, or if the handler
1405 * acknowledged the error
1406 */
1407 LOG_WARNING("TAP %s:",
1408 jtag_tap_name(field->tap));
1409 if (compare_failed)
1410 {
1411 char *captured_char = buf_to_str(captured, (num_bits > DEBUG_JTAG_IOZ) ? DEBUG_JTAG_IOZ : num_bits, 16);
1412 char *in_check_value_char = buf_to_str(field->in_check_value, (num_bits > DEBUG_JTAG_IOZ) ? DEBUG_JTAG_IOZ : num_bits, 16);
1413
1414 if (field->in_check_mask)
1415 {
1416 char *in_check_mask_char;
1417 in_check_mask_char = buf_to_str(field->in_check_mask, (num_bits > DEBUG_JTAG_IOZ) ? DEBUG_JTAG_IOZ : num_bits, 16);
1418 LOG_WARNING("value captured during scan didn't pass the requested check:");
1419 LOG_WARNING("captured: 0x%s check_value: 0x%s check_mask: 0x%s",
1420 captured_char, in_check_value_char, in_check_mask_char);
1421 free(in_check_mask_char);
1422 }
1423 else
1424 {
1425 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);
1426 }
1427
1428 free(captured_char);
1429 free(in_check_value_char);
1430
1431 retval = ERROR_JTAG_QUEUE_FAILED;
1432 }
1433
1434 }
1435 return retval;
1436 }
1437
1438 /*
1439 set up checking of this field using the in_handler. The values passed in must be valid until
1440 after jtag_execute() has completed.
1441 */
1442 void jtag_set_check_value(scan_field_t *field, u8 *value, u8 *mask, error_handler_t *in_error_handler)
1443 {
1444 if (value)
1445 field->in_handler = jtag_check_value;
1446 else
1447 field->in_handler = NULL; /* No check, e.g. embeddedice uses value==NULL to indicate no check */
1448 field->in_handler_priv = NULL;
1449 field->in_check_value = value;
1450 field->in_check_mask = mask;
1451 }
1452
1453 enum scan_type jtag_scan_type(scan_command_t *cmd)
1454 {
1455 int i;
1456 int type = 0;
1457
1458 for (i = 0; i < cmd->num_fields; i++)
1459 {
1460 if (cmd->fields[i].in_value || cmd->fields[i].in_handler)
1461 type |= SCAN_IN;
1462 if (cmd->fields[i].out_value)
1463 type |= SCAN_OUT;
1464 }
1465
1466 return type;
1467 }
1468
1469 int MINIDRIVER(interface_jtag_execute_queue)(void)
1470 {
1471 int retval;
1472
1473 if (jtag==NULL)
1474 {
1475 LOG_ERROR("No JTAG interface configured yet. Issue 'init' command in startup scripts before communicating with targets.");
1476 return ERROR_FAIL;
1477 }
1478
1479 retval = jtag->execute_queue();
1480
1481 cmd_queue_free();
1482
1483 jtag_command_queue = NULL;
1484 last_comand_pointer = &jtag_command_queue;
1485
1486 return retval;
1487 }
1488
1489 int jtag_execute_queue(void)
1490 {
1491 int retval=interface_jtag_execute_queue();
1492 if (retval==ERROR_OK)
1493 {
1494 retval=jtag_error;
1495 }
1496 jtag_error=ERROR_OK;
1497 return retval;
1498 }
1499
1500 int jtag_reset_callback(enum jtag_event event, void *priv)
1501 {
1502 jtag_tap_t *tap = priv;
1503
1504 LOG_DEBUG("-");
1505
1506 if (event == JTAG_TRST_ASSERTED)
1507 {
1508 buf_set_ones(tap->cur_instr, tap->ir_length);
1509 tap->bypass = 1;
1510 }
1511
1512 return ERROR_OK;
1513 }
1514
1515 void jtag_sleep(u32 us)
1516 {
1517 alive_sleep(us/1000);
1518 }
1519
1520 /* Try to examine chain layout according to IEEE 1149.1 §12
1521 */
1522 int jtag_examine_chain(void)
1523 {
1524 jtag_tap_t *tap;
1525 scan_field_t field;
1526 u8 idcode_buffer[JTAG_MAX_CHAIN_SIZE * 4];
1527 int i;
1528 int bit_count;
1529 int device_count = 0;
1530 u8 zero_check = 0x0;
1531 u8 one_check = 0xff;
1532
1533 field.tap = NULL;
1534 field.num_bits = sizeof(idcode_buffer) * 8;
1535 field.out_value = idcode_buffer;
1536 field.out_mask = NULL;
1537 field.in_value = idcode_buffer;
1538 field.in_check_value = NULL;
1539 field.in_check_mask = NULL;
1540 field.in_handler = NULL;
1541 field.in_handler_priv = NULL;
1542
1543 for (i = 0; i < JTAG_MAX_CHAIN_SIZE; i++)
1544 {
1545 buf_set_u32(idcode_buffer, i * 32, 32, 0x000000FF);
1546 }
1547
1548 jtag_add_plain_dr_scan(1, &field, TAP_RESET);
1549 jtag_execute_queue();
1550
1551 for (i = 0; i < JTAG_MAX_CHAIN_SIZE * 4; i++)
1552 {
1553 zero_check |= idcode_buffer[i];
1554 one_check &= idcode_buffer[i];
1555 }
1556
1557 /* if there wasn't a single non-zero bit or if all bits were one, the scan isn't valid */
1558 if ((zero_check == 0x00) || (one_check == 0xff))
1559 {
1560 LOG_ERROR("JTAG communication failure, check connection, JTAG interface, target power etc.");
1561 return ERROR_JTAG_INIT_FAILED;
1562 }
1563
1564 // point at the 1st tap
1565 tap = jtag_NextEnabledTap(NULL);
1566 if( tap == NULL ){
1567 LOG_ERROR("JTAG: No taps enabled?");
1568 return ERROR_JTAG_INIT_FAILED;
1569 }
1570
1571 for (bit_count = 0; bit_count < (JTAG_MAX_CHAIN_SIZE * 32) - 31;)
1572 {
1573 u32 idcode = buf_get_u32(idcode_buffer, bit_count, 32);
1574 if ((idcode & 1) == 0)
1575 {
1576 /* LSB must not be 0, this indicates a device in bypass */
1577 LOG_WARNING("Tap/Device does not have IDCODE");
1578 idcode=0;
1579
1580 bit_count += 1;
1581 }
1582 else
1583 {
1584 u32 manufacturer;
1585 u32 part;
1586 u32 version;
1587
1588 if (idcode == 0x000000FF)
1589 {
1590 int unexpected=0;
1591 /* End of chain (invalid manufacturer ID)
1592 *
1593 * The JTAG examine is the very first thing that happens
1594 *
1595 * A single JTAG device requires only 64 bits to be read back correctly.
1596 *
1597 * The code below adds a check that the rest of the data scanned (640 bits)
1598 * are all as expected. This helps diagnose/catch problems with the JTAG chain
1599 *
1600 * earlier and gives more helpful/explicit error messages.
1601 */
1602 for (bit_count += 32; bit_count < (JTAG_MAX_CHAIN_SIZE * 32) - 31;bit_count += 32)
1603 {
1604 idcode = buf_get_u32(idcode_buffer, bit_count, 32);
1605 if (unexpected||(idcode != 0x000000FF))
1606 {
1607 LOG_WARNING("Unexpected idcode after end of chain! %d 0x%08x", bit_count, idcode);
1608 unexpected = 1;
1609 }
1610 }
1611
1612 break;
1613 }
1614
1615 #define EXTRACT_MFG(X) (((X) & 0xffe) >> 1)
1616 manufacturer = EXTRACT_MFG(idcode);
1617 #define EXTRACT_PART(X) (((X) & 0xffff000) >> 12)
1618 part = EXTRACT_PART(idcode);
1619 #define EXTRACT_VER(X) (((X) & 0xf0000000) >> 28)
1620 version = EXTRACT_VER(idcode);
1621
1622 LOG_INFO("JTAG tap: %s tap/device found: 0x%8.8x (Manufacturer: 0x%3.3x, Part: 0x%4.4x, Version: 0x%1.1x)",
1623 ((tap != NULL) ? (tap->dotted_name) : "(not-named)"),
1624 idcode, manufacturer, part, version);
1625
1626 bit_count += 32;
1627 }
1628 if (tap)
1629 {
1630 tap->idcode = idcode;
1631
1632 if (tap->expected_ids_cnt > 0) {
1633 /* Loop over the expected identification codes and test for a match */
1634 u8 ii;
1635 for (ii = 0; ii < tap->expected_ids_cnt; ii++) {
1636 if( tap->idcode == tap->expected_ids[ii] ){
1637 break;
1638 }
1639 }
1640
1641 /* If none of the expected ids matched, log an error */
1642 if (ii == tap->expected_ids_cnt) {
1643 LOG_ERROR("JTAG tap: %s got: 0x%08x (mfg: 0x%3.3x, part: 0x%4.4x, ver: 0x%1.1x)",
1644 tap->dotted_name,
1645 idcode,
1646 EXTRACT_MFG( tap->idcode ),
1647 EXTRACT_PART( tap->idcode ),
1648 EXTRACT_VER( tap->idcode ) );
1649 for (ii = 0; ii < tap->expected_ids_cnt; ii++) {
1650 LOG_ERROR("JTAG tap: %s expected %hhu of %hhu: 0x%08x (mfg: 0x%3.3x, part: 0x%4.4x, ver: 0x%1.1x)",
1651 tap->dotted_name,
1652 ii + 1,
1653 tap->expected_ids_cnt,
1654 tap->expected_ids[ii],
1655 EXTRACT_MFG( tap->expected_ids[ii] ),
1656 EXTRACT_PART( tap->expected_ids[ii] ),
1657 EXTRACT_VER( tap->expected_ids[ii] ) );
1658 }
1659
1660 return ERROR_JTAG_INIT_FAILED;
1661 } else {
1662 LOG_INFO("JTAG Tap/device matched");
1663 }
1664 } else {
1665 #if 0
1666 LOG_INFO("JTAG TAP ID: 0x%08x - Unknown - please report (A) chipname and (B) idcode to the openocd project",
1667 tap->idcode);
1668 #endif
1669 }
1670 tap = jtag_NextEnabledTap(tap);
1671 }
1672 device_count++;
1673 }
1674
1675 /* see if number of discovered devices matches configuration */
1676 if (device_count != jtag_NumEnabledTaps())
1677 {
1678 LOG_ERROR("number of discovered devices in JTAG chain (%i) doesn't match (enabled) configuration (%i), total taps: %d",
1679 device_count, jtag_NumEnabledTaps(), jtag_NumTotalTaps());
1680 LOG_ERROR("check the config file and ensure proper JTAG communication (connections, speed, ...)");
1681 return ERROR_JTAG_INIT_FAILED;
1682 }
1683
1684 return ERROR_OK;
1685 }
1686
1687 int jtag_validate_chain(void)
1688 {
1689 jtag_tap_t *tap;
1690 int total_ir_length = 0;
1691 u8 *ir_test = NULL;
1692 scan_field_t field;
1693 int chain_pos = 0;
1694
1695 tap = NULL;
1696 total_ir_length = 0;
1697 for(;;){
1698 tap = jtag_NextEnabledTap(tap);
1699 if( tap == NULL ){
1700 break;
1701 }
1702 total_ir_length += tap->ir_length;
1703 }
1704
1705 total_ir_length += 2;
1706 ir_test = malloc(CEIL(total_ir_length, 8));
1707 buf_set_ones(ir_test, total_ir_length);
1708
1709 field.tap = NULL;
1710 field.num_bits = total_ir_length;
1711 field.out_value = ir_test;
1712 field.out_mask = NULL;
1713 field.in_value = ir_test;
1714 field.in_check_value = NULL;
1715 field.in_check_mask = NULL;
1716 field.in_handler = NULL;
1717 field.in_handler_priv = NULL;
1718
1719 jtag_add_plain_ir_scan(1, &field, TAP_RESET);
1720 jtag_execute_queue();
1721
1722 tap = NULL;
1723 chain_pos = 0;
1724 int val;
1725 for(;;){
1726 tap = jtag_NextEnabledTap(tap);
1727 if( tap == NULL ){
1728 break;
1729 }
1730
1731 val = buf_get_u32(ir_test, chain_pos, 2);
1732 if (val != 0x1)
1733 {
1734 char *cbuf = buf_to_str(ir_test, total_ir_length, 16);
1735 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);
1736 free(cbuf);
1737 free(ir_test);
1738 return ERROR_JTAG_INIT_FAILED;
1739 }
1740 chain_pos += tap->ir_length;
1741 }
1742
1743 val = buf_get_u32(ir_test, chain_pos, 2);
1744 if (val != 0x3)
1745 {
1746 char *cbuf = buf_to_str(ir_test, total_ir_length, 16);
1747 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);
1748 free(cbuf);
1749 free(ir_test);
1750 return ERROR_JTAG_INIT_FAILED;
1751 }
1752
1753 free(ir_test);
1754
1755 return ERROR_OK;
1756 }
1757
1758 enum jtag_tap_cfg_param {
1759 JCFG_EVENT
1760 };
1761
1762 static Jim_Nvp nvp_config_opts[] = {
1763 { .name = "-event", .value = JCFG_EVENT },
1764
1765 { .name = NULL, .value = -1 }
1766 };
1767
1768 static int
1769 jtag_tap_configure_cmd( Jim_GetOptInfo *goi,
1770 jtag_tap_t * tap)
1771 {
1772 Jim_Nvp *n;
1773 Jim_Obj *o;
1774 int e;
1775
1776 /* parse config or cget options */
1777 while (goi->argc > 0) {
1778 Jim_SetEmptyResult (goi->interp);
1779
1780 e = Jim_GetOpt_Nvp(goi, nvp_config_opts, &n);
1781 if (e != JIM_OK) {
1782 Jim_GetOpt_NvpUnknown(goi, nvp_config_opts, 0);
1783 return e;
1784 }
1785
1786 switch (n->value) {
1787 case JCFG_EVENT:
1788 if (goi->argc == 0) {
1789 Jim_WrongNumArgs( goi->interp, goi->argc, goi->argv, "-event ?event-name? ..." );
1790 return JIM_ERR;
1791 }
1792
1793 e = Jim_GetOpt_Nvp( goi, nvp_jtag_tap_event, &n );
1794 if (e != JIM_OK) {
1795 Jim_GetOpt_NvpUnknown(goi, nvp_jtag_tap_event, 1);
1796 return e;
1797 }
1798
1799 if (goi->isconfigure) {
1800 if (goi->argc != 1) {
1801 Jim_WrongNumArgs(goi->interp, goi->argc, goi->argv, "-event ?event-name? ?EVENT-BODY?");
1802 return JIM_ERR;
1803 }
1804 } else {
1805 if (goi->argc != 0) {
1806 Jim_WrongNumArgs(goi->interp, goi->argc, goi->argv, "-event ?event-name?");
1807 return JIM_ERR;
1808 }
1809 }
1810
1811 {
1812 jtag_tap_event_action_t *jteap;
1813
1814 jteap = tap->event_action;
1815 /* replace existing? */
1816 while (jteap) {
1817 if (jteap->event == n->value) {
1818 break;
1819 }
1820 jteap = jteap->next;
1821 }
1822
1823 if (goi->isconfigure) {
1824 if (jteap == NULL) {
1825 /* create new */
1826 jteap = calloc(1, sizeof (*jteap));
1827 }
1828 jteap->event = n->value;
1829 Jim_GetOpt_Obj( goi, &o);
1830 if (jteap->body) {
1831 Jim_DecrRefCount(interp, jteap->body);
1832 }
1833 jteap->body = Jim_DuplicateObj(goi->interp, o);
1834 Jim_IncrRefCount(jteap->body);
1835
1836 /* add to head of event list */
1837 jteap->next = tap->event_action;
1838 tap->event_action = jteap;
1839 Jim_SetEmptyResult(goi->interp);
1840 } else {
1841 /* get */
1842 if (jteap == NULL) {
1843 Jim_SetEmptyResult(goi->interp);
1844 } else {
1845 Jim_SetResult(goi->interp, Jim_DuplicateObj(goi->interp, jteap->body));
1846 }
1847 }
1848 }
1849 /* loop for more */
1850 break;
1851 }
1852 } /* while (goi->argc) */
1853
1854 return JIM_OK;
1855 }
1856
1857 static int jim_newtap_cmd( Jim_GetOptInfo *goi )
1858 {
1859 jtag_tap_t *pTap;
1860 jtag_tap_t **ppTap;
1861 jim_wide w;
1862 int x;
1863 int e;
1864 int reqbits;
1865 Jim_Nvp *n;
1866 char *cp;
1867 const Jim_Nvp opts[] = {
1868 #define NTAP_OPT_IRLEN 0
1869 { .name = "-irlen" , .value = NTAP_OPT_IRLEN },
1870 #define NTAP_OPT_IRMASK 1
1871 { .name = "-irmask" , .value = NTAP_OPT_IRMASK },
1872 #define NTAP_OPT_IRCAPTURE 2
1873 { .name = "-ircapture" , .value = NTAP_OPT_IRCAPTURE },
1874 #define NTAP_OPT_ENABLED 3
1875 { .name = "-enable" , .value = NTAP_OPT_ENABLED },
1876 #define NTAP_OPT_DISABLED 4
1877 { .name = "-disable" , .value = NTAP_OPT_DISABLED },
1878 #define NTAP_OPT_EXPECTED_ID 5
1879 { .name = "-expected-id" , .value = NTAP_OPT_EXPECTED_ID },
1880 { .name = NULL , .value = -1 },
1881 };
1882
1883 pTap = malloc( sizeof(jtag_tap_t) );
1884 memset( pTap, 0, sizeof(*pTap) );
1885 if( !pTap ){
1886 Jim_SetResult_sprintf( goi->interp, "no memory");
1887 return JIM_ERR;
1888 }
1889 /*
1890 * we expect CHIP + TAP + OPTIONS
1891 * */
1892 if( goi->argc < 3 ){
1893 Jim_SetResult_sprintf(goi->interp, "Missing CHIP TAP OPTIONS ....");
1894 return JIM_ERR;
1895 }
1896 Jim_GetOpt_String( goi, &cp, NULL );
1897 pTap->chip = strdup(cp);
1898
1899 Jim_GetOpt_String( goi, &cp, NULL );
1900 pTap->tapname = strdup(cp);
1901
1902 /* name + dot + name + null */
1903 x = strlen(pTap->chip) + 1 + strlen(pTap->tapname) + 1;
1904 cp = malloc( x );
1905 sprintf( cp, "%s.%s", pTap->chip, pTap->tapname );
1906 pTap->dotted_name = cp;
1907
1908 LOG_DEBUG("Creating New Tap, Chip: %s, Tap: %s, Dotted: %s, %d params",
1909 pTap->chip, pTap->tapname, pTap->dotted_name, goi->argc);
1910
1911 /* default is enabled */
1912 pTap->enabled = 1;
1913
1914 /* deal with options */
1915 #define NTREQ_IRLEN 1
1916 #define NTREQ_IRCAPTURE 2
1917 #define NTREQ_IRMASK 4
1918
1919 /* clear them as we find them */
1920 reqbits = (NTREQ_IRLEN | NTREQ_IRCAPTURE | NTREQ_IRMASK);
1921
1922 while( goi->argc ){
1923 e = Jim_GetOpt_Nvp( goi, opts, &n );
1924 if( e != JIM_OK ){
1925 Jim_GetOpt_NvpUnknown( goi, opts, 0 );
1926 return e;
1927 }
1928 LOG_DEBUG("Processing option: %s", n->name );
1929 switch( n->value ){
1930 case NTAP_OPT_ENABLED:
1931 pTap->enabled = 1;
1932 break;
1933 case NTAP_OPT_DISABLED:
1934 pTap->enabled = 0;
1935 break;
1936 case NTAP_OPT_EXPECTED_ID:
1937 {
1938 u32 *new_expected_ids;
1939
1940 e = Jim_GetOpt_Wide( goi, &w );
1941 if( e != JIM_OK) {
1942 Jim_SetResult_sprintf(goi->interp, "option: %s bad parameter", n->name);
1943 return e;
1944 }
1945
1946 new_expected_ids = malloc(sizeof(u32) * (pTap->expected_ids_cnt + 1));
1947 if (new_expected_ids == NULL) {
1948 Jim_SetResult_sprintf( goi->interp, "no memory");
1949 return JIM_ERR;
1950 }
1951
1952 memcpy(new_expected_ids, pTap->expected_ids, sizeof(u32) * pTap->expected_ids_cnt);
1953
1954 new_expected_ids[pTap->expected_ids_cnt] = w;
1955
1956 free(pTap->expected_ids);
1957 pTap->expected_ids = new_expected_ids;
1958 pTap->expected_ids_cnt++;
1959 break;
1960 }
1961 case NTAP_OPT_IRLEN:
1962 case NTAP_OPT_IRMASK:
1963 case NTAP_OPT_IRCAPTURE:
1964 e = Jim_GetOpt_Wide( goi, &w );
1965 if( e != JIM_OK ){
1966 Jim_SetResult_sprintf( goi->interp, "option: %s bad parameter", n->name );
1967 return e;
1968 }
1969 if( (w < 0) || (w > 0xffff) ){
1970 /* wacky value */
1971 Jim_SetResult_sprintf( goi->interp, "option: %s - wacky value: %d (0x%x)",
1972 n->name, (int)(w), (int)(w));
1973 return JIM_ERR;
1974 }
1975 switch(n->value){
1976 case NTAP_OPT_IRLEN:
1977 pTap->ir_length = w;
1978 reqbits &= (~(NTREQ_IRLEN));
1979 break;
1980 case NTAP_OPT_IRMASK:
1981 pTap->ir_capture_mask = w;
1982 reqbits &= (~(NTREQ_IRMASK));
1983 break;
1984 case NTAP_OPT_IRCAPTURE:
1985 pTap->ir_capture_value = w;
1986 reqbits &= (~(NTREQ_IRCAPTURE));
1987 break;
1988 }
1989 } /* switch(n->value) */
1990 } /* while( goi->argc ) */
1991
1992 /* Did we get all the options? */
1993 if( reqbits ){
1994 // no
1995 Jim_SetResult_sprintf( goi->interp,
1996 "newtap: %s missing required parameters",
1997 pTap->dotted_name);
1998 /* TODO: Tell user what is missing :-( */
1999 /* no memory leaks pelase */
2000 free(((void *)(pTap->expected_ids)));
2001 free(((void *)(pTap->chip)));
2002 free(((void *)(pTap->tapname)));
2003 free(((void *)(pTap->dotted_name)));
2004 free(((void *)(pTap)));
2005 return JIM_ERR;
2006 }
2007
2008 pTap->expected = malloc( pTap->ir_length );
2009 pTap->expected_mask = malloc( pTap->ir_length );
2010 pTap->cur_instr = malloc( pTap->ir_length );
2011
2012 buf_set_u32( pTap->expected,
2013 0,
2014 pTap->ir_length,
2015 pTap->ir_capture_value );
2016 buf_set_u32( pTap->expected_mask,
2017 0,
2018 pTap->ir_length,
2019 pTap->ir_capture_mask );
2020 buf_set_ones( pTap->cur_instr,
2021 pTap->ir_length );
2022
2023 pTap->bypass = 1;
2024
2025 jtag_register_event_callback(jtag_reset_callback, pTap );
2026
2027 ppTap = &(jtag_all_taps);
2028 while( (*ppTap) != NULL ){
2029 ppTap = &((*ppTap)->next_tap);
2030 }
2031 *ppTap = pTap;
2032 {
2033 static int n_taps = 0;
2034 pTap->abs_chain_position = n_taps++;
2035 }
2036 LOG_DEBUG( "Created Tap: %s @ abs position %d, irlen %d, capture: 0x%x mask: 0x%x",
2037 (*ppTap)->dotted_name,
2038 (*ppTap)->abs_chain_position,
2039 (*ppTap)->ir_length,
2040 (*ppTap)->ir_capture_value,
2041 (*ppTap)->ir_capture_mask );
2042
2043 return ERROR_OK;
2044 }
2045
2046 static int jim_jtag_command( Jim_Interp *interp, int argc, Jim_Obj *const *argv )
2047 {
2048 Jim_GetOptInfo goi;
2049 int e;
2050 Jim_Nvp *n;
2051 Jim_Obj *o;
2052 struct command_context_s *context;
2053
2054 enum {
2055 JTAG_CMD_INTERFACE,
2056 JTAG_CMD_INIT_RESET,
2057 JTAG_CMD_NEWTAP,
2058 JTAG_CMD_TAPENABLE,
2059 JTAG_CMD_TAPDISABLE,
2060 JTAG_CMD_TAPISENABLED,
2061 JTAG_CMD_CONFIGURE,
2062 JTAG_CMD_CGET
2063 };
2064
2065 const Jim_Nvp jtag_cmds[] = {
2066 { .name = "interface" , .value = JTAG_CMD_INTERFACE },
2067 { .name = "arp_init-reset", .value = JTAG_CMD_INIT_RESET },
2068 { .name = "newtap" , .value = JTAG_CMD_NEWTAP },
2069 { .name = "tapisenabled" , .value = JTAG_CMD_TAPISENABLED },
2070 { .name = "tapenable" , .value = JTAG_CMD_TAPENABLE },
2071 { .name = "tapdisable" , .value = JTAG_CMD_TAPDISABLE },
2072 { .name = "configure" , .value = JTAG_CMD_CONFIGURE },
2073 { .name = "cget" , .value = JTAG_CMD_CGET },
2074
2075 { .name = NULL, .value = -1 },
2076 };
2077
2078 context = Jim_GetAssocData(interp, "context");
2079 /* go past the command */
2080 Jim_GetOpt_Setup( &goi, interp, argc-1, argv+1 );
2081
2082 e = Jim_GetOpt_Nvp( &goi, jtag_cmds, &n );
2083 if( e != JIM_OK ){
2084 Jim_GetOpt_NvpUnknown( &goi, jtag_cmds, 0 );
2085 return e;
2086 }
2087 Jim_SetEmptyResult( goi.interp );
2088 switch( n->value ){
2089 case JTAG_CMD_INTERFACE:
2090 /* return the name of the interface */
2091 /* TCL code might need to know the exact type... */
2092 /* FUTURE: we allow this as a means to "set" the interface. */
2093 if( goi.argc != 0 ){
2094 Jim_WrongNumArgs( goi.interp, 1, goi.argv-1, "(no params)");
2095 return JIM_ERR;
2096 }
2097 Jim_SetResultString( goi.interp, jtag_interface->name, -1 );
2098 return JIM_OK;
2099 case JTAG_CMD_INIT_RESET:
2100 if( goi.argc != 0 ){
2101 Jim_WrongNumArgs( goi.interp, 1, goi.argv-1, "(no params)");
2102 return JIM_ERR;
2103 }
2104 e = jtag_init_reset(context);
2105 if( e != ERROR_OK ){
2106 Jim_SetResult_sprintf( goi.interp, "error: %d", e);
2107 return JIM_ERR;
2108 }
2109 return JIM_OK;
2110 case JTAG_CMD_NEWTAP:
2111 return jim_newtap_cmd( &goi );
2112 break;
2113 case JTAG_CMD_TAPISENABLED:
2114 case JTAG_CMD_TAPENABLE:
2115 case JTAG_CMD_TAPDISABLE:
2116 if( goi.argc != 1 ){
2117 Jim_SetResultString( goi.interp, "Too many parameters",-1 );
2118 return JIM_ERR;
2119 }
2120
2121 {
2122 jtag_tap_t *t;
2123 t = jtag_TapByJimObj( goi.interp, goi.argv[0] );
2124 if( t == NULL ){
2125 return JIM_ERR;
2126 }
2127 switch( n->value ){
2128 case JTAG_CMD_TAPISENABLED:
2129 e = t->enabled;
2130 break;
2131 case JTAG_CMD_TAPENABLE:
2132 jtag_tap_handle_event( t, JTAG_TAP_EVENT_ENABLE);
2133 e = 1;
2134 t->enabled = e;
2135 break;
2136 case JTAG_CMD_TAPDISABLE:
2137 jtag_tap_handle_event( t, JTAG_TAP_EVENT_DISABLE);
2138 e = 0;
2139 t->enabled = e;
2140 break;
2141 }
2142 Jim_SetResult( goi.interp, Jim_NewIntObj( goi.interp, e ) );
2143 return JIM_OK;
2144 }
2145 break;
2146
2147 case JTAG_CMD_CGET:
2148 if( goi.argc < 2 ){
2149 Jim_WrongNumArgs( goi.interp, 0, NULL, "?tap-name? -option ...");
2150 return JIM_ERR;
2151 }
2152
2153 {
2154 jtag_tap_t *t;
2155
2156 Jim_GetOpt_Obj(&goi, &o);
2157 t = jtag_TapByJimObj( goi.interp, o );
2158 if( t == NULL ){
2159 return JIM_ERR;
2160 }
2161
2162 goi.isconfigure = 0;
2163 return jtag_tap_configure_cmd( &goi, t);
2164 }
2165 break;
2166
2167 case JTAG_CMD_CONFIGURE:
2168 if( goi.argc < 3 ){
2169 Jim_WrongNumArgs( goi.interp, 0, NULL, "?tap-name? -option ?VALUE? ...");
2170 return JIM_ERR;
2171 }
2172
2173 {
2174 jtag_tap_t *t;
2175
2176 Jim_GetOpt_Obj(&goi, &o);
2177 t = jtag_TapByJimObj( goi.interp, o );
2178 if( t == NULL ){
2179 return JIM_ERR;
2180 }
2181
2182 goi.isconfigure = 1;
2183 return jtag_tap_configure_cmd( &goi, t);
2184 }
2185 }
2186
2187 return JIM_ERR;
2188 }
2189
2190 int jtag_register_commands(struct command_context_s *cmd_ctx)
2191 {
2192 register_jim( cmd_ctx, "jtag", jim_jtag_command, "perform jtag tap actions");
2193
2194 register_command(cmd_ctx, NULL, "interface", handle_interface_command,
2195 COMMAND_CONFIG, "try to configure interface");
2196 register_command(cmd_ctx, NULL, "jtag_speed", handle_jtag_speed_command,
2197 COMMAND_ANY, "set jtag speed (if supported)");
2198 register_command(cmd_ctx, NULL, "jtag_khz", handle_jtag_khz_command,
2199 COMMAND_ANY, "same as jtag_speed, except it takes maximum khz as arguments. 0 KHz = RTCK.");
2200 register_command(cmd_ctx, NULL, "jtag_device", handle_jtag_device_command,
2201 COMMAND_CONFIG, "jtag_device <ir_length> <ir_expected> <ir_mask>");
2202 register_command(cmd_ctx, NULL, "reset_config", handle_reset_config_command,
2203 COMMAND_ANY,
2204 "[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]");
2205 register_command(cmd_ctx, NULL, "jtag_nsrst_delay", handle_jtag_nsrst_delay_command,
2206 COMMAND_ANY, "jtag_nsrst_delay <ms> - delay after deasserting srst in ms");
2207 register_command(cmd_ctx, NULL, "jtag_ntrst_delay", handle_jtag_ntrst_delay_command,
2208 COMMAND_ANY, "jtag_ntrst_delay <ms> - delay after deasserting trst in ms");
2209
2210 register_command(cmd_ctx, NULL, "scan_chain", handle_scan_chain_command,
2211 COMMAND_EXEC, "print current scan chain configuration");
2212
2213 register_command(cmd_ctx, NULL, "endstate", handle_endstate_command,
2214 COMMAND_EXEC, "finish JTAG operations in <tap_state>");
2215 register_command(cmd_ctx, NULL, "jtag_reset", handle_jtag_reset_command,
2216 COMMAND_EXEC, "toggle reset lines <trst> <srst>");
2217 register_command(cmd_ctx, NULL, "runtest", handle_runtest_command,
2218 COMMAND_EXEC, "move to Run-Test/Idle, and execute <num_cycles>");
2219 register_command(cmd_ctx, NULL, "irscan", handle_irscan_command,
2220 COMMAND_EXEC, "execute IR scan <device> <instr> [dev2] [instr2] ...");
2221 register_jim(cmd_ctx, "drscan", Jim_Command_drscan, "execute DR scan <device> <num_bits> <value> <num_bits1> <value2> ...");
2222
2223 register_command(cmd_ctx, NULL, "verify_ircapture", handle_verify_ircapture_command,
2224 COMMAND_ANY, "verify value captured during Capture-IR <enable|disable>");
2225 return ERROR_OK;
2226 }
2227
2228 int jtag_interface_init(struct command_context_s *cmd_ctx)
2229 {
2230 if (jtag)
2231 return ERROR_OK;
2232
2233 if (!jtag_interface)
2234 {
2235 /* nothing was previously specified by "interface" command */
2236 LOG_ERROR("JTAG interface has to be specified, see \"interface\" command");
2237 return ERROR_JTAG_INVALID_INTERFACE;
2238 }
2239 if(hasKHz)
2240 {
2241 jtag_interface->khz(speed_khz, &jtag_speed);
2242 hasKHz = 0;
2243 }
2244
2245 if (jtag_interface->init() != ERROR_OK)
2246 return ERROR_JTAG_INIT_FAILED;
2247
2248 jtag = jtag_interface;
2249 return ERROR_OK;
2250 }
2251
2252 static int jtag_init_inner(struct command_context_s *cmd_ctx)
2253 {
2254 jtag_tap_t *tap;
2255 int retval;
2256
2257 LOG_DEBUG("Init JTAG chain");
2258
2259 tap = jtag_NextEnabledTap(NULL);
2260 if( tap == NULL ){
2261 LOG_ERROR("There are no enabled taps?");
2262 return ERROR_JTAG_INIT_FAILED;
2263 }
2264
2265 jtag_add_tlr();
2266 if ((retval=jtag_execute_queue())!=ERROR_OK)
2267 return retval;
2268
2269 /* examine chain first, as this could discover the real chain layout */
2270 if (jtag_examine_chain() != ERROR_OK)
2271 {
2272 LOG_ERROR("trying to validate configured JTAG chain anyway...");
2273 }
2274
2275 if (jtag_validate_chain() != ERROR_OK)
2276 {
2277 LOG_WARNING("Could not validate JTAG chain, continuing anyway...");
2278 }
2279
2280 return ERROR_OK;
2281 }
2282
2283 int jtag_init_reset(struct command_context_s *cmd_ctx)
2284 {
2285 int retval;
2286
2287 if ((retval=jtag_interface_init(cmd_ctx)) != ERROR_OK)
2288 return retval;
2289
2290 LOG_DEBUG("Trying to bring the JTAG controller to life by asserting TRST / RESET");
2291
2292 /* Reset can happen after a power cycle.
2293 *
2294 * Ideally we would only assert TRST or run RESET before the target reset.
2295 *
2296 * However w/srst_pulls_trst, trst is asserted together with the target
2297 * reset whether we want it or not.
2298 *
2299 * NB! Some targets have JTAG circuitry disabled until a
2300 * trst & srst has been asserted.
2301 *
2302 * NB! here we assume nsrst/ntrst delay are sufficient!
2303 *
2304 * NB! order matters!!!! srst *can* disconnect JTAG circuitry
2305 *
2306 */
2307 jtag_add_reset(1, 0); /* RESET or TRST */
2308 if (jtag_reset_config & RESET_HAS_SRST)
2309 {
2310 jtag_add_reset(1, 1);
2311 if ((jtag_reset_config & RESET_SRST_PULLS_TRST)==0)
2312 jtag_add_reset(0, 1);
2313 }
2314 jtag_add_reset(0, 0);
2315 if ((retval = jtag_execute_queue()) != ERROR_OK)
2316 return retval;
2317
2318 /* Check that we can communication on the JTAG chain + eventually we want to
2319 * be able to perform enumeration only after OpenOCD has started
2320 * telnet and GDB server
2321 *
2322 * That would allow users to more easily perform any magic they need to before
2323 * reset happens.
2324 */
2325 return jtag_init_inner(cmd_ctx);
2326 }
2327
2328 int jtag_init(struct command_context_s *cmd_ctx)
2329 {
2330 int retval;
2331 if ((retval=jtag_interface_init(cmd_ctx)) != ERROR_OK)
2332 return retval;
2333 if (jtag_init_inner(cmd_ctx)==ERROR_OK)
2334 {
2335 return ERROR_OK;
2336 }
2337 return jtag_init_reset(cmd_ctx);
2338 }
2339
2340 static int default_khz(int khz, int *jtag_speed)
2341 {
2342 LOG_ERROR("Translation from khz to jtag_speed not implemented");
2343 return ERROR_FAIL;
2344 }
2345
2346 static int default_speed_div(int speed, int *khz)
2347 {
2348 LOG_ERROR("Translation from jtag_speed to khz not implemented");
2349 return ERROR_FAIL;
2350 }
2351
2352 static int default_power_dropout(int *dropout)
2353 {
2354 *dropout=0; /* by default we can't detect power dropout */
2355 return ERROR_OK;
2356 }
2357
2358 static int default_srst_asserted(int *srst_asserted)
2359 {
2360 *srst_asserted=0; /* by default we can't detect srst asserted */
2361 return ERROR_OK;
2362 }
2363
2364 int handle_interface_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2365 {
2366 int i;
2367 int retval;
2368
2369 /* check whether the interface is already configured */
2370 if (jtag_interface)
2371 {
2372 LOG_WARNING("Interface already configured, ignoring");
2373 return ERROR_OK;
2374 }
2375
2376 /* interface name is a mandatory argument */
2377 if (argc < 1 || args[0][0] == '\0')
2378 {
2379 return ERROR_COMMAND_SYNTAX_ERROR;
2380 }
2381
2382 for (i=0; jtag_interfaces[i]; i++)
2383 {
2384 if (strcmp(args[0], jtag_interfaces[i]->name) == 0)
2385 {
2386 if ((retval = jtag_interfaces[i]->register_commands(cmd_ctx)) != ERROR_OK)
2387 {
2388 return retval;
2389 }
2390
2391 jtag_interface = jtag_interfaces[i];
2392
2393 if (jtag_interface->khz == NULL)
2394 {
2395 jtag_interface->khz = default_khz;
2396 }
2397 if (jtag_interface->speed_div == NULL)
2398 {
2399 jtag_interface->speed_div = default_speed_div;
2400 }
2401 if (jtag_interface->power_dropout == NULL)
2402 {
2403 jtag_interface->power_dropout = default_power_dropout;
2404 }
2405 if (jtag_interface->srst_asserted == NULL)
2406 {
2407 jtag_interface->srst_asserted = default_srst_asserted;
2408 }
2409
2410 return ERROR_OK;
2411 }
2412 }
2413
2414 /* no valid interface was found (i.e. the configuration option,
2415 * didn't match one of the compiled-in interfaces
2416 */
2417 LOG_ERROR("No valid jtag interface found (%s)", args[0]);
2418 LOG_ERROR("compiled-in jtag interfaces:");
2419 for (i = 0; jtag_interfaces[i]; i++)
2420 {
2421 LOG_ERROR("%i: %s", i, jtag_interfaces[i]->name);
2422 }
2423
2424 return ERROR_JTAG_INVALID_INTERFACE;
2425 }
2426
2427 int handle_jtag_device_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2428 {
2429 int e;
2430 char buf[1024];
2431 Jim_Obj *newargs[ 10 ];
2432 /*
2433 * CONVERT SYNTAX
2434 * argv[-1] = command
2435 * argv[ 0] = ir length
2436 * argv[ 1] = ir capture
2437 * argv[ 2] = ir mask
2438 * argv[ 3] = not actually used by anything but in the docs
2439 */
2440
2441 if( argc < 4 ){
2442 command_print( cmd_ctx, "OLD DEPRECATED SYNTAX: Please use the NEW syntax");
2443 return ERROR_OK;
2444 }
2445 command_print( cmd_ctx, "OLD SYNTAX: DEPRECATED - translating to new syntax");
2446 command_print( cmd_ctx, "jtag newtap CHIP TAP -irlen %s -ircapture %s -irvalue %s",
2447 args[0],
2448 args[1],
2449 args[2] );
2450 command_print( cmd_ctx, "Example: STM32 has 2 taps, the cortexM3(len4) + boundryscan(len5)");
2451 command_print( cmd_ctx, "jtag newtap stm32 cortexm3 ....., thus creating the tap: \"stm32.cortexm3\"");
2452 command_print( cmd_ctx, "jtag newtap stm32 boundry ....., and the tap: \"stm32.boundery\"");
2453 command_print( cmd_ctx, "And then refer to the taps by the dotted name.");
2454
2455 newargs[0] = Jim_NewStringObj( interp, "jtag", -1 );
2456 newargs[1] = Jim_NewStringObj( interp, "newtap", -1 );
2457 sprintf( buf, "chip%d", jtag_NumTotalTaps() );
2458 newargs[2] = Jim_NewStringObj( interp, buf, -1 );
2459 sprintf( buf, "tap%d", jtag_NumTotalTaps() );
2460 newargs[3] = Jim_NewStringObj( interp, buf, -1 );
2461 newargs[4] = Jim_NewStringObj( interp, "-irlen", -1 );
2462 newargs[5] = Jim_NewStringObj( interp, args[0], -1 );
2463 newargs[6] = Jim_NewStringObj( interp, "-ircapture", -1 );
2464 newargs[7] = Jim_NewStringObj( interp, args[1], -1 );
2465 newargs[8] = Jim_NewStringObj( interp, "-irmask", -1 );
2466 newargs[9] = Jim_NewStringObj( interp, args[2], -1 );
2467
2468 command_print( cmd_ctx, "NEW COMMAND:");
2469 sprintf( buf, "%s %s %s %s %s %s %s %s %s %s",
2470 Jim_GetString( newargs[0], NULL ),
2471 Jim_GetString( newargs[1], NULL ),
2472 Jim_GetString( newargs[2], NULL ),
2473 Jim_GetString( newargs[3], NULL ),
2474 Jim_GetString( newargs[4], NULL ),
2475 Jim_GetString( newargs[5], NULL ),
2476 Jim_GetString( newargs[6], NULL ),
2477 Jim_GetString( newargs[7], NULL ),
2478 Jim_GetString( newargs[8], NULL ),
2479 Jim_GetString( newargs[9], NULL ) );
2480
2481 e = jim_jtag_command( interp, 10, newargs );
2482 if( e != JIM_OK ){
2483 command_print( cmd_ctx, "%s", Jim_GetString( Jim_GetResult(interp), NULL ) );
2484 }
2485 return e;
2486 }
2487
2488 int handle_scan_chain_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2489 {
2490 jtag_tap_t *tap;
2491
2492 tap = jtag_all_taps;
2493 command_print(cmd_ctx, " TapName | Enabled | IdCode Expected IrLen IrCap IrMask Instr ");
2494 command_print(cmd_ctx, "---|--------------------|---------|------------|------------|------|------|------|---------");
2495
2496 while( tap ){
2497 u32 expected, expected_mask, cur_instr, ii;
2498 expected = buf_get_u32(tap->expected, 0, tap->ir_length);
2499 expected_mask = buf_get_u32(tap->expected_mask, 0, tap->ir_length);
2500 cur_instr = buf_get_u32(tap->cur_instr, 0, tap->ir_length);
2501
2502 command_print(cmd_ctx,
2503 "%2d | %-18s | %c | 0x%08x | 0x%08x | 0x%02x | 0x%02x | 0x%02x | 0x%02x",
2504 tap->abs_chain_position,
2505 tap->dotted_name,
2506 tap->enabled ? 'Y' : 'n',
2507 tap->idcode,
2508 (tap->expected_ids_cnt > 0 ? tap->expected_ids[0] : 0),
2509 tap->ir_length,
2510 expected,
2511 expected_mask,
2512 cur_instr);
2513
2514 for (ii = 1; ii < tap->expected_ids_cnt; ii++) {
2515 command_print(cmd_ctx, " | | | | 0x%08x | | | | ",
2516 tap->expected_ids[ii]);
2517 }
2518
2519 tap = tap->next_tap;
2520 }
2521
2522 return ERROR_OK;
2523 }
2524
2525 int handle_reset_config_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2526 {
2527 if (argc < 1)
2528 return ERROR_COMMAND_SYNTAX_ERROR;
2529
2530 if (argc >= 1)
2531 {
2532 if (strcmp(args[0], "none") == 0)
2533 jtag_reset_config = RESET_NONE;
2534 else if (strcmp(args[0], "trst_only") == 0)
2535 jtag_reset_config = RESET_HAS_TRST;
2536 else if (strcmp(args[0], "srst_only") == 0)
2537 jtag_reset_config = RESET_HAS_SRST;
2538 else if (strcmp(args[0], "trst_and_srst") == 0)
2539 jtag_reset_config = RESET_TRST_AND_SRST;
2540 else
2541 {
2542 LOG_ERROR("(1) invalid reset_config argument (%s), defaulting to none", args[0]);
2543 jtag_reset_config = RESET_NONE;
2544 return ERROR_INVALID_ARGUMENTS;
2545 }
2546 }
2547
2548 if (argc >= 2)
2549 {
2550 if (strcmp(args[1], "separate") == 0)
2551 {
2552 /* seperate reset lines - default */
2553 } else
2554 {
2555 if (strcmp(args[1], "srst_pulls_trst") == 0)
2556 jtag_reset_config |= RESET_SRST_PULLS_TRST;
2557 else if (strcmp(args[1], "trst_pulls_srst") == 0)
2558 jtag_reset_config |= RESET_TRST_PULLS_SRST;
2559 else if (strcmp(args[1], "combined") == 0)
2560 jtag_reset_config |= RESET_SRST_PULLS_TRST | RESET_TRST_PULLS_SRST;
2561 else
2562 {
2563 LOG_ERROR("(2) invalid reset_config argument (%s), defaulting to none", args[1]);
2564 jtag_reset_config = RESET_NONE;
2565 return ERROR_INVALID_ARGUMENTS;
2566 }
2567 }
2568 }
2569
2570 if (argc >= 3)
2571 {
2572 if (strcmp(args[2], "trst_open_drain") == 0)
2573 jtag_reset_config |= RESET_TRST_OPEN_DRAIN;
2574 else if (strcmp(args[2], "trst_push_pull") == 0)
2575 jtag_reset_config &= ~RESET_TRST_OPEN_DRAIN;
2576 else
2577 {
2578 LOG_ERROR("(3) invalid reset_config argument (%s) defaulting to none", args[2] );
2579 jtag_reset_config = RESET_NONE;
2580 return ERROR_INVALID_ARGUMENTS;
2581 }
2582 }
2583
2584 if (argc >= 4)
2585 {
2586 if (strcmp(args[3], "srst_push_pull") == 0)
2587 jtag_reset_config |= RESET_SRST_PUSH_PULL;
2588 else if (strcmp(args[3], "srst_open_drain") == 0)
2589 jtag_reset_config &= ~RESET_SRST_PUSH_PULL;
2590 else
2591 {
2592 LOG_ERROR("(4) invalid reset_config argument (%s), defaulting to none", args[3]);
2593 jtag_reset_config = RESET_NONE;
2594 return ERROR_INVALID_ARGUMENTS;
2595 }
2596 }
2597
2598 return ERROR_OK;
2599 }
2600
2601 int handle_jtag_nsrst_delay_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2602 {
2603 if (argc < 1)
2604 {
2605 LOG_ERROR("jtag_nsrst_delay <ms> command takes one required argument");
2606 exit(-1);
2607 }
2608 else
2609 {
2610 jtag_nsrst_delay = strtoul(args[0], NULL, 0);
2611 }
2612
2613 return ERROR_OK;
2614 }
2615
2616 int handle_jtag_ntrst_delay_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2617 {
2618 if (argc < 1)
2619 {
2620 LOG_ERROR("jtag_ntrst_delay <ms> command takes one required argument");
2621 exit(-1);
2622 }
2623 else
2624 {
2625 jtag_ntrst_delay = strtoul(args[0], NULL, 0);
2626 }
2627
2628 return ERROR_OK;
2629 }
2630
2631 int handle_jtag_speed_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2632 {
2633 int retval=ERROR_OK;
2634
2635 if (argc == 1)
2636 {
2637 LOG_DEBUG("handle jtag speed");
2638
2639 int cur_speed = 0;
2640 cur_speed = jtag_speed = strtoul(args[0], NULL, 0);
2641
2642 /* this command can be called during CONFIG,
2643 * in which case jtag isn't initialized */
2644 if (jtag)
2645 {
2646 retval=jtag->speed(cur_speed);
2647 }
2648 } else if (argc == 0)
2649 {
2650 } else
2651 {
2652 return ERROR_COMMAND_SYNTAX_ERROR;
2653 }
2654 command_print(cmd_ctx, "jtag_speed: %d", jtag_speed);
2655
2656 return retval;
2657 }
2658
2659 int handle_jtag_khz_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2660 {
2661 int retval=ERROR_OK;
2662 LOG_DEBUG("handle jtag khz");
2663
2664 if(argc == 1)
2665 {
2666 speed_khz = strtoul(args[0], NULL, 0);
2667 if (jtag != NULL)
2668 {
2669 int cur_speed = 0;
2670 LOG_DEBUG("have interface set up");
2671 int speed_div1;
2672 if ((retval=jtag->khz(speed_khz, &speed_div1))!=ERROR_OK)
2673 {
2674 speed_khz = 0;
2675 return retval;
2676 }
2677
2678 cur_speed = jtag_speed = speed_div1;
2679
2680 retval=jtag->speed(cur_speed);
2681 } else
2682 {
2683 hasKHz = 1;
2684 }
2685 } else if (argc==0)
2686 {
2687 } else
2688 {
2689 return ERROR_COMMAND_SYNTAX_ERROR;
2690 }
2691
2692 if (jtag!=NULL)
2693 {
2694 if ((retval=jtag->speed_div(jtag_speed, &speed_khz))!=ERROR_OK)
2695 return retval;
2696 }
2697
2698 if (speed_khz==0)
2699 {
2700 command_print(cmd_ctx, "RCLK - adaptive");
2701 } else
2702 {
2703 command_print(cmd_ctx, "%d kHz", speed_khz);
2704 }
2705 return retval;
2706
2707 }
2708
2709 int handle_endstate_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2710 {
2711 enum tap_state state;
2712
2713 if (argc < 1)
2714 {
2715 return ERROR_COMMAND_SYNTAX_ERROR;
2716 }
2717 else
2718 {
2719 for (state = 0; state < 16; state++)
2720 {
2721 if (strcmp(args[0], jtag_state_name(state)) == 0)
2722 {
2723 jtag_add_end_state(state);
2724 jtag_execute_queue();
2725 }
2726 }
2727 }
2728 command_print(cmd_ctx, "current endstate: %s", jtag_state_name(cmd_queue_end_state));
2729
2730 return ERROR_OK;
2731 }
2732
2733 int handle_jtag_reset_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2734 {
2735 int trst = -1;
2736 int srst = -1;
2737
2738 if (argc < 2)
2739 {
2740 return ERROR_COMMAND_SYNTAX_ERROR;
2741 }
2742
2743 if (args[0][0] == '1')
2744 trst = 1;
2745 else if (args[0][0] == '0')
2746 trst = 0;
2747 else
2748 {
2749 return ERROR_COMMAND_SYNTAX_ERROR;
2750 }
2751
2752 if (args[1][0] == '1')
2753 srst = 1;
2754 else if (args[1][0] == '0')
2755 srst = 0;
2756 else
2757 {
2758 return ERROR_COMMAND_SYNTAX_ERROR;
2759 }
2760
2761 if (jtag_interface_init(cmd_ctx) != ERROR_OK)
2762 return ERROR_JTAG_INIT_FAILED;
2763
2764 jtag_add_reset(trst, srst);
2765 jtag_execute_queue();
2766
2767 return ERROR_OK;
2768 }
2769
2770 int handle_runtest_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2771 {
2772 if (argc < 1)
2773 {
2774 return ERROR_COMMAND_SYNTAX_ERROR;
2775 }
2776
2777 jtag_add_runtest(strtol(args[0], NULL, 0), -1);
2778 jtag_execute_queue();
2779
2780 return ERROR_OK;
2781
2782 }
2783
2784 int handle_irscan_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2785 {
2786 int i;
2787 scan_field_t *fields;
2788 jtag_tap_t *tap;
2789
2790 if ((argc < 2) || (argc % 2))
2791 {
2792 return ERROR_COMMAND_SYNTAX_ERROR;
2793 }
2794
2795 fields = malloc(sizeof(scan_field_t) * argc / 2);
2796
2797 for (i = 0; i < argc / 2; i++)
2798 {
2799 tap = jtag_TapByString( args[i*2] );
2800 if (tap==NULL)
2801 {
2802 command_print( cmd_ctx, "Tap: %s unknown", args[i*2] );
2803 return ERROR_FAIL;
2804 }
2805 int field_size = tap->ir_length;
2806 fields[i].tap = tap;
2807 fields[i].out_value = malloc(CEIL(field_size, 8));
2808 buf_set_u32(fields[i].out_value, 0, field_size, strtoul(args[i*2+1], NULL, 0));
2809 fields[i].out_mask = NULL;
2810 fields[i].in_value = NULL;
2811 fields[i].in_check_mask = NULL;
2812 fields[i].in_handler = NULL;
2813 fields[i].in_handler_priv = NULL;
2814 }
2815
2816 jtag_add_ir_scan(argc / 2, fields, -1);
2817 jtag_execute_queue();
2818
2819 for (i = 0; i < argc / 2; i++)
2820 free(fields[i].out_value);
2821
2822 free (fields);
2823
2824 return ERROR_OK;
2825 }
2826
2827 int Jim_Command_drscan(Jim_Interp *interp, int argc, Jim_Obj *const *args)
2828 {
2829 int retval;
2830 scan_field_t *fields;
2831 int num_fields;
2832 int field_count = 0;
2833 int i, e;
2834 jtag_tap_t *tap;
2835
2836 /* args[1] = device
2837 * args[2] = num_bits
2838 * args[3] = hex string
2839 * ... repeat num bits and hex string ...
2840 */
2841 if ((argc < 4) || ((argc % 2)!=0))
2842 {
2843 Jim_WrongNumArgs(interp, 1, args, "wrong arguments");
2844 return JIM_ERR;
2845 }
2846
2847 for (i = 2; i < argc; i+=2)
2848 {
2849 long bits;
2850
2851 e = Jim_GetLong(interp, args[i], &bits);
2852 if (e != JIM_OK)
2853 return e;
2854 }
2855
2856 tap = jtag_TapByJimObj( interp, args[1] );
2857 if( tap == NULL ){
2858 return JIM_ERR;
2859 }
2860
2861 num_fields=(argc-2)/2;
2862 fields = malloc(sizeof(scan_field_t) * num_fields);
2863 for (i = 2; i < argc; i+=2)
2864 {
2865 long bits;
2866 int len;
2867 const char *str;
2868
2869 Jim_GetLong(interp, args[i], &bits);
2870 str = Jim_GetString(args[i+1], &len);
2871
2872 fields[field_count].tap = tap;
2873 fields[field_count].num_bits = bits;
2874 fields[field_count].out_value = malloc(CEIL(bits, 8));
2875 str_to_buf(str, len, fields[field_count].out_value, bits, 0);
2876 fields[field_count].out_mask = NULL;
2877 fields[field_count].in_value = fields[field_count].out_value;
2878 fields[field_count].in_check_mask = NULL;
2879 fields[field_count].in_check_value = NULL;
2880 fields[field_count].in_handler = NULL;
2881 fields[field_count++].in_handler_priv = NULL;
2882 }
2883
2884 jtag_add_dr_scan(num_fields, fields, -1);
2885 retval = jtag_execute_queue();
2886 if (retval != ERROR_OK)
2887 {
2888 Jim_SetResultString(interp, "drscan: jtag execute failed",-1);
2889 return JIM_ERR;
2890 }
2891
2892 field_count=0;
2893 Jim_Obj *list = Jim_NewListObj(interp, NULL, 0);
2894 for (i = 2; i < argc; i+=2)
2895 {
2896 long bits;
2897 char *str;
2898
2899 Jim_GetLong(interp, args[i], &bits);
2900 str = buf_to_str(fields[field_count].in_value, bits, 16);
2901 free(fields[field_count].out_value);
2902
2903 Jim_ListAppendElement(interp, list, Jim_NewStringObj(interp, str, strlen(str)));
2904 free(str);
2905 field_count++;
2906 }
2907
2908 Jim_SetResult(interp, list);
2909
2910 free(fields);
2911
2912 return JIM_OK;
2913 }
2914
2915 int handle_verify_ircapture_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2916 {
2917 if (argc == 1)
2918 {
2919 if (strcmp(args[0], "enable") == 0)
2920 {
2921 jtag_verify_capture_ir = 1;
2922 }
2923 else if (strcmp(args[0], "disable") == 0)
2924 {
2925 jtag_verify_capture_ir = 0;
2926 } else
2927 {
2928 return ERROR_COMMAND_SYNTAX_ERROR;
2929 }
2930 } else if (argc != 0)
2931 {
2932 return ERROR_COMMAND_SYNTAX_ERROR;
2933 }
2934
2935 command_print(cmd_ctx, "verify Capture-IR is %s", (jtag_verify_capture_ir) ? "enabled": "disabled");
2936
2937 return ERROR_OK;
2938 }
2939
2940 int jtag_power_dropout(int *dropout)
2941 {
2942 return jtag->power_dropout(dropout);
2943 }
2944
2945 int jtag_srst_asserted(int *srst_asserted)
2946 {
2947 return jtag->srst_asserted(srst_asserted);
2948 }
2949
2950 void jtag_tap_handle_event( jtag_tap_t * tap, enum jtag_tap_event e)
2951 {
2952 jtag_tap_event_action_t * jteap;
2953 int done;
2954
2955 jteap = tap->event_action;
2956
2957 done = 0;
2958 while (jteap) {
2959 if (jteap->event == e) {
2960 done = 1;
2961 LOG_DEBUG( "JTAG tap: %s event: %d (%s) action: %s\n",
2962 tap->dotted_name,
2963 e,
2964 Jim_Nvp_value2name_simple(nvp_jtag_tap_event, e)->name,
2965 Jim_GetString(jteap->body, NULL) );
2966 if (Jim_EvalObj(interp, jteap->body) != JIM_OK) {
2967 Jim_PrintErrorMessage(interp);
2968 }
2969 }
2970
2971 jteap = jteap->next;
2972 }
2973
2974 if (!done) {
2975 LOG_DEBUG( "event %d %s - no action",
2976 e,
2977 Jim_Nvp_value2name_simple( nvp_jtag_tap_event, e)->name);
2978 }
2979 }
2980
2981
2982 /* map state number to SVF state string */
2983 const char* jtag_state_name(enum tap_state state)
2984 {
2985 const char* ret;
2986
2987 switch( state )
2988 {
2989 case TAP_RESET: ret = "RESET"; break;
2990 case TAP_IDLE: ret = "IDLE"; break;
2991 case TAP_DRSELECT: ret = "DRSELECT"; break;
2992 case TAP_DRCAPTURE: ret = "DRCAPTURE"; break;
2993 case TAP_DRSHIFT: ret = "DRSHIFT"; break;
2994 case TAP_DREXIT1: ret = "DREXIT1"; break;
2995 case TAP_DRPAUSE: ret = "DRPAUSE"; break;
2996 case TAP_DREXIT2: ret = "DREXIT2"; break;
2997 case TAP_DRUPDATE: ret = "DRUPDATE"; break;
2998 case TAP_IRSELECT: ret = "IRSELECT"; break;
2999 case TAP_IRCAPTURE: ret = "IRCAPTURE"; break;
3000 case TAP_IRSHIFT: ret = "IRSHIFT"; break;
3001 case TAP_IREXIT1: ret = "IREXIT1"; break;
3002 case TAP_IRPAUSE: ret = "IRPAUSE"; break;
3003 case TAP_IREXIT2: ret = "IREXIT2"; break;
3004 case TAP_IRUPDATE: ret = "IRUPDATE"; break;
3005 default: ret = "???";
3006 }
3007
3008 return ret;
3009 }
3010
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)