Code Review / openocd.git / blob
? search:
summary | shortlog | log | commit | commitdiff | review | tree
history | raw | HEAD
make jtag_add_statemove() internal to the driver.
[openocd.git] / src / jtag / jtag.c
1 /***************************************************************************
2 * Copyright (C) 2005 by Dominic Rath *
3 * Dominic.Rath@gmx.de *
4 * *
5 * This program is free software; you can redistribute it and/or modify *
6 * it under the terms of the GNU General Public License as published by *
7 * the Free Software Foundation; either version 2 of the License, or *
8 * (at your option) any later version. *
9 * *
10 * This program is distributed in the hope that it will be useful, *
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
13 * GNU General Public License for more details. *
14 * *
15 * You should have received a copy of the GNU General Public License *
16 * along with this program; if not, write to the *
17 * Free Software Foundation, Inc., *
18 * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
19 ***************************************************************************/
20 #ifdef HAVE_CONFIG_H
21 #include "config.h"
22 #endif
23
24 #include "replacements.h"
25
26 #include "jtag.h"
27
28 #include "command.h"
29 #include "log.h"
30 #include "interpreter.h"
31
32 #include "stdlib.h"
33 #include "string.h"
34 #include <unistd.h>
35
36
37 /* note that this is not marked as static as it must be available from outside jtag.c for those
38 that implement the jtag_xxx() minidriver layer
39 */
40 int jtag_error=ERROR_OK;
41
42
43 char* tap_state_strings[16] =
44 {
45 "tlr",
46 "sds", "cd", "sd", "e1d", "pd", "e2d", "ud",
47 "rti",
48 "sis", "ci", "si", "e1i", "pi", "e2i", "ui"
49 };
50
51 typedef struct cmd_queue_page_s
52 {
53 void *address;
54 size_t used;
55 struct cmd_queue_page_s *next;
56 } cmd_queue_page_t;
57
58 #define CMD_QUEUE_PAGE_SIZE (1024 * 1024)
59 static cmd_queue_page_t *cmd_queue_pages = NULL;
60
61 /* tap_move[i][j]: tap movement command to go from state i to state j
62 * 0: Test-Logic-Reset
63 * 1: Run-Test/Idle
64 * 2: Shift-DR
65 * 3: Pause-DR
66 * 4: Shift-IR
67 * 5: Pause-IR
68 *
69 * SD->SD and SI->SI have to be caught in interface specific code
70 */
71 u8 tap_move[6][6] =
72 {
73 /* TLR RTI SD PD SI PI */
74 {0x7f, 0x00, 0x17, 0x0a, 0x1b, 0x16}, /* TLR */
75 {0x7f, 0x00, 0x25, 0x05, 0x2b, 0x0b}, /* RTI */
76 {0x7f, 0x31, 0x00, 0x01, 0x0f, 0x2f}, /* SD */
77 {0x7f, 0x30, 0x20, 0x17, 0x1e, 0x2f}, /* PD */
78 {0x7f, 0x31, 0x07, 0x17, 0x00, 0x01}, /* SI */
79 {0x7f, 0x30, 0x1c, 0x17, 0x20, 0x2f} /* PI */
80 };
81
82 int tap_move_map[16] = {
83 0, -1, -1, 2, -1, 3, -1, -1,
84 1, -1, -1, 4, -1, 5, -1, -1
85 };
86
87 tap_transition_t tap_transitions[16] =
88 {
89 {TAP_TLR, TAP_RTI}, /* TLR */
90 {TAP_SIS, TAP_CD}, /* SDS */
91 {TAP_E1D, TAP_SD}, /* CD */
92 {TAP_E1D, TAP_SD}, /* SD */
93 {TAP_UD, TAP_PD}, /* E1D */
94 {TAP_E2D, TAP_PD}, /* PD */
95 {TAP_UD, TAP_SD}, /* E2D */
96 {TAP_SDS, TAP_RTI}, /* UD */
97 {TAP_SDS, TAP_RTI}, /* RTI */
98 {TAP_TLR, TAP_CI}, /* SIS */
99 {TAP_E1I, TAP_SI}, /* CI */
100 {TAP_E1I, TAP_SI}, /* SI */
101 {TAP_UI, TAP_PI}, /* E1I */
102 {TAP_E2I, TAP_PI}, /* PI */
103 {TAP_UI, TAP_SI}, /* E2I */
104 {TAP_SDS, TAP_RTI} /* UI */
105 };
106
107 char* jtag_event_strings[] =
108 {
109 "JTAG controller reset(tms or TRST)"
110 };
111
112 enum tap_state end_state = TAP_TLR;
113 enum tap_state cur_state = TAP_TLR;
114 int jtag_trst = 0;
115 int jtag_srst = 0;
116
117 jtag_command_t *jtag_command_queue = NULL;
118 jtag_command_t **last_comand_pointer = &jtag_command_queue;
119 jtag_device_t *jtag_devices = NULL;
120 int jtag_num_devices = 0;
121 int jtag_ir_scan_size = 0;
122 enum reset_types jtag_reset_config = RESET_NONE;
123 enum tap_state cmd_queue_end_state = TAP_TLR;
124 enum tap_state cmd_queue_cur_state = TAP_TLR;
125
126 int jtag_verify_capture_ir = 1;
127
128 /* how long the OpenOCD should wait before attempting JTAG communication after reset lines deasserted (in ms) */
129 int jtag_nsrst_delay = 0; /* default to no nSRST delay */
130 int jtag_ntrst_delay = 0; /* default to no nTRST delay */
131
132 /* maximum number of JTAG devices expected in the chain
133 */
134 #define JTAG_MAX_CHAIN_SIZE 20
135
136 /* callbacks to inform high-level handlers about JTAG state changes */
137 jtag_event_callback_t *jtag_event_callbacks;
138
139 /* jtag interfaces (parport, FTDI-USB, TI-USB, ...)
140 */
141
142 #if BUILD_ECOSBOARD == 1
143 extern jtag_interface_t eCosBoard_interface;
144 #endif
145
146 #if BUILD_PARPORT == 1
147 extern jtag_interface_t parport_interface;
148 #endif
149
150 #if BUILD_FT2232_FTD2XX == 1
151 extern jtag_interface_t ft2232_interface;
152 #endif
153
154 #if BUILD_FT2232_LIBFTDI == 1
155 extern jtag_interface_t ft2232_interface;
156 #endif
157
158 #if BUILD_AMTJTAGACCEL == 1
159 extern jtag_interface_t amt_jtagaccel_interface;
160 #endif
161
162 #if BUILD_EP93XX == 1
163 extern jtag_interface_t ep93xx_interface;
164 #endif
165
166 #if BUILD_AT91RM9200 == 1
167 extern jtag_interface_t at91rm9200_interface;
168 #endif
169
170 #if BUILD_GW16012 == 1
171 extern jtag_interface_t gw16012_interface;
172 #endif
173
174 #if BUILD_PRESTO_LIBFTDI == 1 || BUILD_PRESTO_FTD2XX == 1
175 extern jtag_interface_t presto_interface;
176 #endif
177
178 #if BUILD_USBPROG == 1
179 extern jtag_interface_t usbprog_interface;
180 #endif
181
182 jtag_interface_t *jtag_interfaces[] = {
183 #if BUILD_ECOSBOARD == 1
184 &eCosBoard_interface,
185 #endif
186 #if BUILD_PARPORT == 1
187 &parport_interface,
188 #endif
189 #if BUILD_FT2232_FTD2XX == 1
190 &ft2232_interface,
191 #endif
192 #if BUILD_FT2232_LIBFTDI == 1
193 &ft2232_interface,
194 #endif
195 #if BUILD_AMTJTAGACCEL == 1
196 &amt_jtagaccel_interface,
197 #endif
198 #if BUILD_EP93XX == 1
199 &ep93xx_interface,
200 #endif
201 #if BUILD_AT91RM9200 == 1
202 &at91rm9200_interface,
203 #endif
204 #if BUILD_GW16012 == 1
205 &gw16012_interface,
206 #endif
207 #if BUILD_PRESTO_LIBFTDI == 1 || BUILD_PRESTO_FTD2XX == 1
208 &presto_interface,
209 #endif
210 #if BUILD_USBPROG == 1
211 &usbprog_interface,
212 #endif
213 NULL,
214 };
215
216 jtag_interface_t *jtag = NULL;
217
218 /* configuration */
219 jtag_interface_t *jtag_interface = NULL;
220 int jtag_speed = 0;
221 int jtag_speed_post_reset = 0;
222
223
224 /* forward declarations */
225 void jtag_add_pathmove(int num_states, enum tap_state *path);
226 void jtag_add_runtest(int num_cycles, enum tap_state endstate);
227 void jtag_add_reset(int trst, int srst);
228 void jtag_add_end_state(enum tap_state endstate);
229 void jtag_add_sleep(u32 us);
230 int jtag_execute_queue(void);
231 int jtag_cancel_queue(void);
232
233 /* jtag commands */
234 int handle_interface_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
235 int handle_jtag_speed_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
236 int handle_jtag_khz_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
237 int handle_jtag_device_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
238 int handle_reset_config_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
239 int handle_jtag_nsrst_delay_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
240 int handle_jtag_ntrst_delay_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
241
242 int handle_scan_chain_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
243
244 int handle_endstate_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
245 int handle_jtag_reset_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
246 int handle_runtest_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
247 int handle_irscan_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
248 int handle_drscan_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
249
250 int handle_verify_ircapture_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
251
252 int jtag_register_event_callback(int (*callback)(enum jtag_event event, void *priv), void *priv)
253 {
254 jtag_event_callback_t **callbacks_p = &jtag_event_callbacks;
255
256 if (callback == NULL)
257 {
258 return ERROR_INVALID_ARGUMENTS;
259 }
260
261 if (*callbacks_p)
262 {
263 while ((*callbacks_p)->next)
264 callbacks_p = &((*callbacks_p)->next);
265 callbacks_p = &((*callbacks_p)->next);
266 }
267
268 (*callbacks_p) = malloc(sizeof(jtag_event_callback_t));
269 (*callbacks_p)->callback = callback;
270 (*callbacks_p)->priv = priv;
271 (*callbacks_p)->next = NULL;
272
273 return ERROR_OK;
274 }
275
276 int jtag_unregister_event_callback(int (*callback)(enum jtag_event event, void *priv))
277 {
278 jtag_event_callback_t **callbacks_p = &jtag_event_callbacks;
279
280 if (callback == NULL)
281 {
282 return ERROR_INVALID_ARGUMENTS;
283 }
284
285 while (*callbacks_p)
286 {
287 jtag_event_callback_t **next = &((*callbacks_p)->next);
288 if ((*callbacks_p)->callback == callback)
289 {
290 free(*callbacks_p);
291 *callbacks_p = *next;
292 }
293 callbacks_p = next;
294 }
295
296 return ERROR_OK;
297 }
298
299 int jtag_call_event_callbacks(enum jtag_event event)
300 {
301 jtag_event_callback_t *callback = jtag_event_callbacks;
302
303 LOG_DEBUG("jtag event: %s", jtag_event_strings[event]);
304
305 while (callback)
306 {
307 callback->callback(event, callback->priv);
308 callback = callback->next;
309 }
310
311 return ERROR_OK;
312 }
313
314 /* returns a pointer to the pointer of the last command in queue
315 * this may be a pointer to the root pointer (jtag_command_queue)
316 * or to the next member of the last but one command
317 */
318 jtag_command_t** jtag_get_last_command_p(void)
319 {
320 /* jtag_command_t *cmd = jtag_command_queue;
321
322 if (cmd)
323 while (cmd->next)
324 cmd = cmd->next;
325 else
326 return &jtag_command_queue;
327
328 return &cmd->next;*/
329
330 return last_comand_pointer;
331 }
332
333 /* returns a pointer to the n-th device in the scan chain */
334 jtag_device_t* jtag_get_device(int num)
335 {
336 jtag_device_t *device = jtag_devices;
337 int i = 0;
338
339 while (device)
340 {
341 if (num == i)
342 return device;
343 device = device->next;
344 i++;
345 }
346
347 LOG_ERROR("jtag device number %d not defined", num);
348 exit(-1);
349 }
350
351 void* cmd_queue_alloc(size_t size)
352 {
353 cmd_queue_page_t **p_page = &cmd_queue_pages;
354 int offset;
355
356 if (*p_page)
357 {
358 while ((*p_page)->next)
359 p_page = &((*p_page)->next);
360 if (CMD_QUEUE_PAGE_SIZE - (*p_page)->used < size)
361 p_page = &((*p_page)->next);
362 }
363
364 if (!*p_page)
365 {
366 *p_page = malloc(sizeof(cmd_queue_page_t));
367 (*p_page)->used = 0;
368 (*p_page)->address = malloc(CMD_QUEUE_PAGE_SIZE);
369 (*p_page)->next = NULL;
370 }
371
372 offset = (*p_page)->used;
373 (*p_page)->used += size;
374
375 u8 *t=(u8 *)((*p_page)->address);
376 return t + offset;
377 }
378
379 void cmd_queue_free()
380 {
381 cmd_queue_page_t *page = cmd_queue_pages;
382
383 while (page)
384 {
385 cmd_queue_page_t *last = page;
386 free(page->address);
387 page = page->next;
388 free(last);
389 }
390
391 cmd_queue_pages = NULL;
392 }
393
394 static void jtag_prelude1()
395 {
396 if (jtag_trst == 1)
397 {
398 LOG_WARNING("JTAG command queued, while TRST is low (TAP in reset)");
399 jtag_error=ERROR_JTAG_TRST_ASSERTED;
400 return;
401 }
402
403 if (cmd_queue_end_state == TAP_TLR)
404 jtag_call_event_callbacks(JTAG_TRST_ASSERTED);
405 }
406
407 static void jtag_prelude(enum tap_state state)
408 {
409 jtag_prelude1();
410
411 if (state != -1)
412 jtag_add_end_state(state);
413
414 cmd_queue_cur_state = cmd_queue_end_state;
415 }
416
417 void jtag_add_ir_scan(int num_fields, scan_field_t *fields, enum tap_state state)
418 {
419 jtag_prelude(state);
420
421 int retval=interface_jtag_add_ir_scan(num_fields, fields, cmd_queue_end_state);
422 if (retval!=ERROR_OK)
423 jtag_error=retval;
424 }
425
426 int MINIDRIVER(interface_jtag_add_ir_scan)(int num_fields, scan_field_t *fields, enum tap_state state)
427 {
428 jtag_command_t **last_cmd;
429 jtag_device_t *device;
430 int i, j;
431 int scan_size = 0;
432
433
434 last_cmd = jtag_get_last_command_p();
435
436 /* allocate memory for a new list member */
437 *last_cmd = cmd_queue_alloc(sizeof(jtag_command_t));
438 (*last_cmd)->next = NULL;
439 last_comand_pointer = &((*last_cmd)->next);
440 (*last_cmd)->type = JTAG_SCAN;
441
442 /* allocate memory for ir scan command */
443 (*last_cmd)->cmd.scan = cmd_queue_alloc(sizeof(scan_command_t));
444 (*last_cmd)->cmd.scan->ir_scan = 1;
445 (*last_cmd)->cmd.scan->num_fields = jtag_num_devices; /* one field per device */
446 (*last_cmd)->cmd.scan->fields = cmd_queue_alloc(jtag_num_devices * sizeof(scan_field_t));
447 (*last_cmd)->cmd.scan->end_state = state;
448
449 for (i = 0; i < jtag_num_devices; i++)
450 {
451 int found = 0;
452 device = jtag_get_device(i);
453 scan_size = device->ir_length;
454 (*last_cmd)->cmd.scan->fields[i].device = i;
455 (*last_cmd)->cmd.scan->fields[i].num_bits = scan_size;
456 (*last_cmd)->cmd.scan->fields[i].in_value = NULL;
457 (*last_cmd)->cmd.scan->fields[i].in_handler = NULL; /* disable verification by default */
458
459 /* search the list */
460 for (j = 0; j < num_fields; j++)
461 {
462 if (i == fields[j].device)
463 {
464 found = 1;
465 (*last_cmd)->cmd.scan->fields[i].out_value = buf_cpy(fields[j].out_value, cmd_queue_alloc(CEIL(scan_size, 8)), scan_size);
466 (*last_cmd)->cmd.scan->fields[i].out_mask = buf_cpy(fields[j].out_mask, cmd_queue_alloc(CEIL(scan_size, 8)), scan_size);
467
468 if (jtag_verify_capture_ir)
469 {
470 if (fields[j].in_handler==NULL)
471 {
472 jtag_set_check_value((*last_cmd)->cmd.scan->fields+i, device->expected, device->expected_mask, NULL);
473 } else
474 {
475 (*last_cmd)->cmd.scan->fields[i].in_handler = fields[j].in_handler;
476 (*last_cmd)->cmd.scan->fields[i].in_handler_priv = fields[j].in_handler_priv;
477 (*last_cmd)->cmd.scan->fields[i].in_check_value = device->expected;
478 (*last_cmd)->cmd.scan->fields[i].in_check_mask = device->expected_mask;
479 }
480 }
481
482 device->bypass = 0;
483 break;
484 }
485 }
486
487 if (!found)
488 {
489 /* if a device isn't listed, set it to BYPASS */
490 (*last_cmd)->cmd.scan->fields[i].out_value = buf_set_ones(cmd_queue_alloc(CEIL(scan_size, 8)), scan_size);
491 (*last_cmd)->cmd.scan->fields[i].out_mask = NULL;
492 device->bypass = 1;
493
494 }
495
496 /* update device information */
497 buf_cpy((*last_cmd)->cmd.scan->fields[i].out_value, jtag_get_device(i)->cur_instr, scan_size);
498 }
499
500 return ERROR_OK;
501 }
502
503 void jtag_add_plain_ir_scan(int num_fields, scan_field_t *fields, enum tap_state state)
504 {
505 jtag_prelude(state);
506
507 int retval=interface_jtag_add_plain_ir_scan(num_fields, fields, cmd_queue_end_state);
508 if (retval!=ERROR_OK)
509 jtag_error=retval;
510 }
511
512 int MINIDRIVER(interface_jtag_add_plain_ir_scan)(int num_fields, scan_field_t *fields, enum tap_state state)
513 {
514 int i;
515 jtag_command_t **last_cmd;
516
517 last_cmd = jtag_get_last_command_p();
518
519 /* allocate memory for a new list member */
520 *last_cmd = cmd_queue_alloc(sizeof(jtag_command_t));
521 (*last_cmd)->next = NULL;
522 last_comand_pointer = &((*last_cmd)->next);
523 (*last_cmd)->type = JTAG_SCAN;
524
525 /* allocate memory for ir scan command */
526 (*last_cmd)->cmd.scan = cmd_queue_alloc(sizeof(scan_command_t));
527 (*last_cmd)->cmd.scan->ir_scan = 1;
528 (*last_cmd)->cmd.scan->num_fields = num_fields;
529 (*last_cmd)->cmd.scan->fields = cmd_queue_alloc(num_fields * sizeof(scan_field_t));
530 (*last_cmd)->cmd.scan->end_state = state;
531
532 for (i = 0; i < num_fields; i++)
533 {
534 int num_bits = fields[i].num_bits;
535 int num_bytes = CEIL(fields[i].num_bits, 8);
536 (*last_cmd)->cmd.scan->fields[i].device = fields[i].device;
537 (*last_cmd)->cmd.scan->fields[i].num_bits = num_bits;
538 (*last_cmd)->cmd.scan->fields[i].out_value = buf_cpy(fields[i].out_value, cmd_queue_alloc(num_bytes), num_bits);
539 (*last_cmd)->cmd.scan->fields[i].out_mask = buf_cpy(fields[i].out_mask, cmd_queue_alloc(num_bytes), num_bits);
540 (*last_cmd)->cmd.scan->fields[i].in_value = fields[i].in_value;
541 (*last_cmd)->cmd.scan->fields[i].in_check_value = fields[i].in_check_value;
542 (*last_cmd)->cmd.scan->fields[i].in_check_mask = fields[i].in_check_mask;
543 (*last_cmd)->cmd.scan->fields[i].in_handler = NULL;
544 (*last_cmd)->cmd.scan->fields[i].in_handler_priv = NULL;
545 }
546 return ERROR_OK;
547 }
548
549 void jtag_add_dr_scan(int num_fields, scan_field_t *fields, enum tap_state state)
550 {
551 jtag_prelude(state);
552
553 int retval=interface_jtag_add_dr_scan(num_fields, fields, cmd_queue_end_state);
554 if (retval!=ERROR_OK)
555 jtag_error=retval;
556 }
557
558 int MINIDRIVER(interface_jtag_add_dr_scan)(int num_fields, scan_field_t *fields, enum tap_state state)
559 {
560 int i, j;
561 int bypass_devices = 0;
562 int field_count = 0;
563 int scan_size;
564
565 jtag_command_t **last_cmd = jtag_get_last_command_p();
566 jtag_device_t *device = jtag_devices;
567
568 /* count devices in bypass */
569 while (device)
570 {
571 if (device->bypass)
572 bypass_devices++;
573 device = device->next;
574 }
575
576 /* allocate memory for a new list member */
577 *last_cmd = cmd_queue_alloc(sizeof(jtag_command_t));
578 last_comand_pointer = &((*last_cmd)->next);
579 (*last_cmd)->next = NULL;
580 (*last_cmd)->type = JTAG_SCAN;
581
582 /* allocate memory for dr scan command */
583 (*last_cmd)->cmd.scan = cmd_queue_alloc(sizeof(scan_command_t));
584 (*last_cmd)->cmd.scan->ir_scan = 0;
585 (*last_cmd)->cmd.scan->num_fields = num_fields + bypass_devices;
586 (*last_cmd)->cmd.scan->fields = cmd_queue_alloc((num_fields + bypass_devices) * sizeof(scan_field_t));
587 (*last_cmd)->cmd.scan->end_state = state;
588
589 for (i = 0; i < jtag_num_devices; i++)
590 {
591 int found = 0;
592 (*last_cmd)->cmd.scan->fields[field_count].device = i;
593
594 for (j = 0; j < num_fields; j++)
595 {
596 if (i == fields[j].device)
597 {
598 found = 1;
599 scan_size = fields[j].num_bits;
600 (*last_cmd)->cmd.scan->fields[field_count].num_bits = scan_size;
601 (*last_cmd)->cmd.scan->fields[field_count].out_value = buf_cpy(fields[j].out_value, cmd_queue_alloc(CEIL(scan_size, 8)), scan_size);
602 (*last_cmd)->cmd.scan->fields[field_count].out_mask = buf_cpy(fields[j].out_mask, cmd_queue_alloc(CEIL(scan_size, 8)), scan_size);
603 (*last_cmd)->cmd.scan->fields[field_count].in_value = fields[j].in_value;
604 (*last_cmd)->cmd.scan->fields[field_count].in_check_value = fields[j].in_check_value;
605 (*last_cmd)->cmd.scan->fields[field_count].in_check_mask = fields[j].in_check_mask;
606 (*last_cmd)->cmd.scan->fields[field_count].in_handler = fields[j].in_handler;
607 (*last_cmd)->cmd.scan->fields[field_count++].in_handler_priv = fields[j].in_handler_priv;
608 }
609 }
610 if (!found)
611 {
612 #ifdef _DEBUG_JTAG_IO_
613 /* if a device isn't listed, the BYPASS register should be selected */
614 if (!jtag_get_device(i)->bypass)
615 {
616 LOG_ERROR("BUG: no scan data for a device not in BYPASS");
617 exit(-1);
618 }
619 #endif
620 /* program the scan field to 1 bit length, and ignore it's value */
621 (*last_cmd)->cmd.scan->fields[field_count].num_bits = 1;
622 (*last_cmd)->cmd.scan->fields[field_count].out_value = NULL;
623 (*last_cmd)->cmd.scan->fields[field_count].out_mask = NULL;
624 (*last_cmd)->cmd.scan->fields[field_count].in_value = NULL;
625 (*last_cmd)->cmd.scan->fields[field_count].in_check_value = NULL;
626 (*last_cmd)->cmd.scan->fields[field_count].in_check_mask = NULL;
627 (*last_cmd)->cmd.scan->fields[field_count].in_handler = NULL;
628 (*last_cmd)->cmd.scan->fields[field_count++].in_handler_priv = NULL;
629 }
630 else
631 {
632 #ifdef _DEBUG_JTAG_IO_
633 /* if a device is listed, the BYPASS register must not be selected */
634 if (jtag_get_device(i)->bypass)
635 {
636 LOG_ERROR("BUG: scan data for a device in BYPASS");
637 exit(-1);
638 }
639 #endif
640 }
641 }
642 return ERROR_OK;
643 }
644
645 void MINIDRIVER(interface_jtag_add_dr_out)(int device_num,
646 int num_fields,
647 int *num_bits,
648 u32 *value,
649 enum tap_state end_state)
650 {
651 int i;
652 int field_count = 0;
653 int scan_size;
654 int bypass_devices = 0;
655
656 jtag_command_t **last_cmd = jtag_get_last_command_p();
657 jtag_device_t *device = jtag_devices;
658 /* count devices in bypass */
659 while (device)
660 {
661 if (device->bypass)
662 bypass_devices++;
663 device = device->next;
664 }
665
666 /* allocate memory for a new list member */
667 *last_cmd = cmd_queue_alloc(sizeof(jtag_command_t));
668 last_comand_pointer = &((*last_cmd)->next);
669 (*last_cmd)->next = NULL;
670 (*last_cmd)->type = JTAG_SCAN;
671
672 /* allocate memory for dr scan command */
673 (*last_cmd)->cmd.scan = cmd_queue_alloc(sizeof(scan_command_t));
674 (*last_cmd)->cmd.scan->ir_scan = 0;
675 (*last_cmd)->cmd.scan->num_fields = num_fields + bypass_devices;
676 (*last_cmd)->cmd.scan->fields = cmd_queue_alloc((num_fields + bypass_devices) * sizeof(scan_field_t));
677 (*last_cmd)->cmd.scan->end_state = end_state;
678
679 for (i = 0; i < jtag_num_devices; i++)
680 {
681 (*last_cmd)->cmd.scan->fields[field_count].device = i;
682
683 if (i == device_num)
684 {
685 int j;
686 #ifdef _DEBUG_JTAG_IO_
687 /* if a device is listed, the BYPASS register must not be selected */
688 if (jtag_get_device(i)->bypass)
689 {
690 LOG_ERROR("BUG: scan data for a device in BYPASS");
691 exit(-1);
692 }
693 #endif
694 for (j = 0; j < num_fields; j++)
695 {
696 u8 out_value[4];
697 scan_size = num_bits[j];
698 buf_set_u32(out_value, 0, scan_size, value[j]);
699 (*last_cmd)->cmd.scan->fields[field_count].num_bits = scan_size;
700 (*last_cmd)->cmd.scan->fields[field_count].out_value = buf_cpy(out_value, cmd_queue_alloc(CEIL(scan_size, 8)), scan_size);
701 (*last_cmd)->cmd.scan->fields[field_count].out_mask = NULL;
702 (*last_cmd)->cmd.scan->fields[field_count].in_value = NULL;
703 (*last_cmd)->cmd.scan->fields[field_count].in_check_value = NULL;
704 (*last_cmd)->cmd.scan->fields[field_count].in_check_mask = NULL;
705 (*last_cmd)->cmd.scan->fields[field_count].in_handler = NULL;
706 (*last_cmd)->cmd.scan->fields[field_count++].in_handler_priv = NULL;
707 }
708 } else
709 {
710 #ifdef _DEBUG_JTAG_IO_
711 /* if a device isn't listed, the BYPASS register should be selected */
712 if (!jtag_get_device(i)->bypass)
713 {
714 LOG_ERROR("BUG: no scan data for a device not in BYPASS");
715 exit(-1);
716 }
717 #endif
718 /* program the scan field to 1 bit length, and ignore it's value */
719 (*last_cmd)->cmd.scan->fields[field_count].num_bits = 1;
720 (*last_cmd)->cmd.scan->fields[field_count].out_value = NULL;
721 (*last_cmd)->cmd.scan->fields[field_count].out_mask = NULL;
722 (*last_cmd)->cmd.scan->fields[field_count].in_value = NULL;
723 (*last_cmd)->cmd.scan->fields[field_count].in_check_value = NULL;
724 (*last_cmd)->cmd.scan->fields[field_count].in_check_mask = NULL;
725 (*last_cmd)->cmd.scan->fields[field_count].in_handler = NULL;
726 (*last_cmd)->cmd.scan->fields[field_count++].in_handler_priv = NULL;
727 }
728 }
729 }
730
731
732
733
734 void jtag_add_plain_dr_scan(int num_fields, scan_field_t *fields, enum tap_state state)
735 {
736 jtag_prelude(state);
737
738 int retval=interface_jtag_add_plain_dr_scan(num_fields, fields, cmd_queue_end_state);
739 if (retval!=ERROR_OK)
740 jtag_error=retval;
741 }
742
743 int MINIDRIVER(interface_jtag_add_plain_dr_scan)(int num_fields, scan_field_t *fields, enum tap_state state)
744 {
745 int i;
746 jtag_command_t **last_cmd = jtag_get_last_command_p();
747
748 /* allocate memory for a new list member */
749 *last_cmd = cmd_queue_alloc(sizeof(jtag_command_t));
750 last_comand_pointer = &((*last_cmd)->next);
751 (*last_cmd)->next = NULL;
752 (*last_cmd)->type = JTAG_SCAN;
753
754 /* allocate memory for scan command */
755 (*last_cmd)->cmd.scan = cmd_queue_alloc(sizeof(scan_command_t));
756 (*last_cmd)->cmd.scan->ir_scan = 0;
757 (*last_cmd)->cmd.scan->num_fields = num_fields;
758 (*last_cmd)->cmd.scan->fields = cmd_queue_alloc(num_fields * sizeof(scan_field_t));
759 (*last_cmd)->cmd.scan->end_state = state;
760
761 for (i = 0; i < num_fields; i++)
762 {
763 int num_bits = fields[i].num_bits;
764 int num_bytes = CEIL(fields[i].num_bits, 8);
765 (*last_cmd)->cmd.scan->fields[i].device = fields[i].device;
766 (*last_cmd)->cmd.scan->fields[i].num_bits = num_bits;
767 (*last_cmd)->cmd.scan->fields[i].out_value = buf_cpy(fields[i].out_value, cmd_queue_alloc(num_bytes), num_bits);
768 (*last_cmd)->cmd.scan->fields[i].out_mask = buf_cpy(fields[i].out_mask, cmd_queue_alloc(num_bytes), num_bits);
769 (*last_cmd)->cmd.scan->fields[i].in_value = fields[i].in_value;
770 (*last_cmd)->cmd.scan->fields[i].in_check_value = fields[i].in_check_value;
771 (*last_cmd)->cmd.scan->fields[i].in_check_mask = fields[i].in_check_mask;
772 (*last_cmd)->cmd.scan->fields[i].in_handler = fields[i].in_handler;
773 (*last_cmd)->cmd.scan->fields[i].in_handler_priv = fields[i].in_handler_priv;
774 }
775
776 return ERROR_OK;
777 }
778
779 void jtag_add_tms()
780 {
781 jtag_prelude(TAP_TLR);
782
783 int retval;
784 retval=interface_jtag_add_tms();
785 if (retval!=ERROR_OK)
786 jtag_error=retval;
787 }
788
789 int MINIDRIVER(interface_jtag_add_tms)()
790 {
791 enum tap_state state = TAP_TLR;
792 jtag_command_t **last_cmd = jtag_get_last_command_p();
793
794 /* allocate memory for a new list member */
795 *last_cmd = cmd_queue_alloc(sizeof(jtag_command_t));
796 last_comand_pointer = &((*last_cmd)->next);
797 (*last_cmd)->next = NULL;
798 (*last_cmd)->type = JTAG_STATEMOVE;
799
800 (*last_cmd)->cmd.statemove = cmd_queue_alloc(sizeof(statemove_command_t));
801 (*last_cmd)->cmd.statemove->end_state = state;
802
803
804 return ERROR_OK;
805 }
806
807 void jtag_add_pathmove(int num_states, enum tap_state *path)
808 {
809 /* the last state has to be a stable state */
810 if (tap_move_map[path[num_states - 1]] == -1)
811 {
812 LOG_ERROR("BUG: TAP path doesn't finish in a stable state");
813 exit(-1);
814 }
815
816 enum tap_state cur_state=cmd_queue_cur_state;
817 int i;
818 for (i=0; i<num_states; i++)
819 {
820 if ((tap_transitions[cur_state].low != path[i])&&
821 (tap_transitions[cur_state].high != path[i]))
822 {
823 LOG_ERROR("BUG: %s -> %s isn't a valid TAP transition", tap_state_strings[cur_state], tap_state_strings[path[i]]);
824 exit(-1);
825 }
826 cur_state = path[i];
827 }
828
829 jtag_prelude1();
830
831 cmd_queue_cur_state = path[num_states - 1];
832
833 int retval=interface_jtag_add_pathmove(num_states, path);
834 if (retval!=ERROR_OK)
835 jtag_error=retval;
836 }
837
838
839 int MINIDRIVER(interface_jtag_add_pathmove)(int num_states, enum tap_state *path)
840 {
841 jtag_command_t **last_cmd = jtag_get_last_command_p();
842 int i;
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_PATHMOVE;
849
850 (*last_cmd)->cmd.pathmove = cmd_queue_alloc(sizeof(pathmove_command_t));
851 (*last_cmd)->cmd.pathmove->num_states = num_states;
852 (*last_cmd)->cmd.pathmove->path = cmd_queue_alloc(sizeof(enum tap_state) * num_states);
853
854 for (i = 0; i < num_states; i++)
855 (*last_cmd)->cmd.pathmove->path[i] = path[i];
856
857 return ERROR_OK;
858 }
859
860 int MINIDRIVER(interface_jtag_add_runtest)(int num_cycles, enum tap_state state)
861 {
862 jtag_command_t **last_cmd = jtag_get_last_command_p();
863
864 /* allocate memory for a new list member */
865 *last_cmd = cmd_queue_alloc(sizeof(jtag_command_t));
866 (*last_cmd)->next = NULL;
867 last_comand_pointer = &((*last_cmd)->next);
868 (*last_cmd)->type = JTAG_RUNTEST;
869
870 (*last_cmd)->cmd.runtest = cmd_queue_alloc(sizeof(runtest_command_t));
871 (*last_cmd)->cmd.runtest->num_cycles = num_cycles;
872 (*last_cmd)->cmd.runtest->end_state = state;
873
874 return ERROR_OK;
875 }
876
877 void jtag_add_runtest(int num_cycles, enum tap_state state)
878 {
879 jtag_prelude(state);
880
881 /* executed by sw or hw fifo */
882 int retval=interface_jtag_add_runtest(num_cycles, cmd_queue_end_state);
883 if (retval!=ERROR_OK)
884 jtag_error=retval;
885 }
886
887 void jtag_add_reset(int req_trst, int req_srst)
888 {
889 int trst_with_tms = 0;
890 int retval;
891
892 /* Make sure that jtag_reset_config allows the requested reset */
893 /* if SRST pulls TRST, we can't fulfill srst == 1 with trst == 0 */
894 if (((jtag_reset_config & RESET_SRST_PULLS_TRST) && (req_srst == 1)) && (req_trst == 0))
895 {
896 LOG_ERROR("BUG: requested reset would assert trst");
897 jtag_error=ERROR_FAIL;
898 return;
899 }
900
901 /* if TRST pulls SRST, we reset with TAP T-L-R */
902 if (((jtag_reset_config & RESET_TRST_PULLS_SRST) && (req_trst == 1)) && (req_srst == 0))
903 {
904 req_trst = 0;
905 trst_with_tms = 1;
906 }
907
908 if (req_srst && !(jtag_reset_config & RESET_HAS_SRST))
909 {
910 LOG_ERROR("BUG: requested nSRST assertion, but the current configuration doesn't support this");
911 jtag_error=ERROR_FAIL;
912 return;
913 }
914
915 if (req_trst && !(jtag_reset_config & RESET_HAS_TRST))
916 {
917 req_trst = 0;
918 trst_with_tms = 1;
919 }
920
921 jtag_trst = req_trst;
922 jtag_srst = req_srst;
923
924 retval = interface_jtag_add_reset(req_trst, req_srst);
925 if (retval!=ERROR_OK)
926 {
927 jtag_error=retval;
928 return;
929 }
930
931 if (jtag_srst)
932 {
933 LOG_DEBUG("SRST line asserted");
934 }
935 else
936 {
937 LOG_DEBUG("SRST line released");
938 if (jtag_nsrst_delay)
939 jtag_add_sleep(jtag_nsrst_delay * 1000);
940 }
941
942 if (trst_with_tms)
943 {
944 LOG_DEBUG("JTAG reset with tms instead of TRST");
945 jtag_add_end_state(TAP_TLR);
946 jtag_add_tms();
947 jtag_call_event_callbacks(JTAG_TRST_ASSERTED);
948 return;
949 }
950
951 if (jtag_trst)
952 {
953 /* we just asserted nTRST, so we're now in Test-Logic-Reset,
954 * and inform possible listeners about this
955 */
956 LOG_DEBUG("TRST line asserted");
957 cmd_queue_cur_state = TAP_TLR;
958 jtag_call_event_callbacks(JTAG_TRST_ASSERTED);
959 }
960 else
961 {
962 /* the nTRST line got deasserted, so we're still in Test-Logic-Reset,
963 * but we might want to add a delay to give the TAP time to settle
964 */
965 LOG_DEBUG("Now in TAP_TLR - Test-Logic-Reset(either due to TRST line asserted or tms reset)");
966 if (jtag_ntrst_delay)
967 jtag_add_sleep(jtag_ntrst_delay * 1000);
968 }
969 }
970
971 int MINIDRIVER(interface_jtag_add_reset)(int req_trst, int req_srst)
972 {
973 jtag_command_t **last_cmd = jtag_get_last_command_p();
974
975 /* allocate memory for a new list member */
976 *last_cmd = cmd_queue_alloc(sizeof(jtag_command_t));
977 (*last_cmd)->next = NULL;
978 last_comand_pointer = &((*last_cmd)->next);
979 (*last_cmd)->type = JTAG_RESET;
980
981 (*last_cmd)->cmd.reset = cmd_queue_alloc(sizeof(reset_command_t));
982 (*last_cmd)->cmd.reset->trst = req_trst;
983 (*last_cmd)->cmd.reset->srst = req_srst;
984
985
986 return ERROR_OK;
987 }
988
989 void jtag_add_end_state(enum tap_state state)
990 {
991 cmd_queue_end_state = state;
992 if ((cmd_queue_end_state == TAP_SD)||(cmd_queue_end_state == TAP_SD))
993 {
994 LOG_ERROR("BUG: TAP_SD/SI can't be end state. Calling code should use a larger scan field");
995 }
996 }
997
998 int MINIDRIVER(interface_jtag_add_sleep)(u32 us)
999 {
1000 jtag_command_t **last_cmd = jtag_get_last_command_p();
1001
1002 /* allocate memory for a new list member */
1003 *last_cmd = cmd_queue_alloc(sizeof(jtag_command_t));
1004 (*last_cmd)->next = NULL;
1005 last_comand_pointer = &((*last_cmd)->next);
1006 (*last_cmd)->type = JTAG_SLEEP;
1007
1008 (*last_cmd)->cmd.sleep = cmd_queue_alloc(sizeof(sleep_command_t));
1009 (*last_cmd)->cmd.sleep->us = us;
1010
1011 return ERROR_OK;
1012 }
1013
1014 void jtag_add_sleep(u32 us)
1015 {
1016 int retval=interface_jtag_add_sleep(us);
1017 if (retval!=ERROR_OK)
1018 jtag_error=retval;
1019 return;
1020 }
1021
1022 int jtag_scan_size(scan_command_t *cmd)
1023 {
1024 int bit_count = 0;
1025 int i;
1026
1027 /* count bits in scan command */
1028 for (i = 0; i < cmd->num_fields; i++)
1029 {
1030 bit_count += cmd->fields[i].num_bits;
1031 }
1032
1033 return bit_count;
1034 }
1035
1036 int jtag_build_buffer(scan_command_t *cmd, u8 **buffer)
1037 {
1038 int bit_count = 0;
1039 int i;
1040
1041 bit_count = jtag_scan_size(cmd);
1042 *buffer = malloc(CEIL(bit_count, 8));
1043
1044 bit_count = 0;
1045
1046 for (i = 0; i < cmd->num_fields; i++)
1047 {
1048 if (cmd->fields[i].out_value)
1049 {
1050 #ifdef _DEBUG_JTAG_IO_
1051 char* char_buf = buf_to_str(cmd->fields[i].out_value, (cmd->fields[i].num_bits > 64) ? 64 : cmd->fields[i].num_bits, 16);
1052 #endif
1053 buf_set_buf(cmd->fields[i].out_value, 0, *buffer, bit_count, cmd->fields[i].num_bits);
1054 #ifdef _DEBUG_JTAG_IO_
1055 LOG_DEBUG("fields[%i].out_value: 0x%s", i, char_buf);
1056 free(char_buf);
1057 #endif
1058 }
1059
1060 bit_count += cmd->fields[i].num_bits;
1061 }
1062
1063 return bit_count;
1064
1065 }
1066
1067 int jtag_read_buffer(u8 *buffer, scan_command_t *cmd)
1068 {
1069 int i;
1070 int bit_count = 0;
1071 int retval;
1072
1073 /* we return ERROR_OK, unless a check fails, or a handler reports a problem */
1074 retval = ERROR_OK;
1075
1076 for (i = 0; i < cmd->num_fields; i++)
1077 {
1078 /* if neither in_value nor in_handler
1079 * are specified we don't have to examine this field
1080 */
1081 if (cmd->fields[i].in_value || cmd->fields[i].in_handler)
1082 {
1083 int num_bits = cmd->fields[i].num_bits;
1084 u8 *captured = buf_set_buf(buffer, bit_count, malloc(CEIL(num_bits, 8)), 0, num_bits);
1085
1086 #ifdef _DEBUG_JTAG_IO_
1087 char *char_buf;
1088
1089 char_buf = buf_to_str(captured, (num_bits > 64) ? 64 : num_bits, 16);
1090 LOG_DEBUG("fields[%i].in_value: 0x%s", i, char_buf);
1091 free(char_buf);
1092 #endif
1093
1094 if (cmd->fields[i].in_value)
1095 {
1096 buf_cpy(captured, cmd->fields[i].in_value, num_bits);
1097
1098 if (cmd->fields[i].in_handler)
1099 {
1100 if (cmd->fields[i].in_handler(cmd->fields[i].in_value, cmd->fields[i].in_handler_priv, cmd->fields+i) != ERROR_OK)
1101 {
1102 LOG_WARNING("in_handler reported a failed check");
1103 retval = ERROR_JTAG_QUEUE_FAILED;
1104 }
1105 }
1106 }
1107
1108 /* no in_value specified, but a handler takes care of the scanned data */
1109 if (cmd->fields[i].in_handler && (!cmd->fields[i].in_value))
1110 {
1111 if (cmd->fields[i].in_handler(captured, cmd->fields[i].in_handler_priv, cmd->fields+i) != ERROR_OK)
1112 {
1113 /* We're going to call the error:handler later, but if the in_handler
1114 * reported an error we report this failure upstream
1115 */
1116 LOG_WARNING("in_handler reported a failed check");
1117 retval = ERROR_JTAG_QUEUE_FAILED;
1118 }
1119 }
1120
1121 free(captured);
1122 }
1123 bit_count += cmd->fields[i].num_bits;
1124 }
1125
1126 return retval;
1127 }
1128
1129 int jtag_check_value(u8 *captured, void *priv, scan_field_t *field)
1130 {
1131 int retval = ERROR_OK;
1132 int num_bits = field->num_bits;
1133
1134 int compare_failed = 0;
1135
1136 if (field->in_check_mask)
1137 compare_failed = buf_cmp_mask(captured, field->in_check_value, field->in_check_mask, num_bits);
1138 else
1139 compare_failed = buf_cmp(captured, field->in_check_value, num_bits);
1140
1141 if (compare_failed)
1142 {
1143 /* An error handler could have caught the failing check
1144 * only report a problem when there wasn't a handler, or if the handler
1145 * acknowledged the error
1146 */
1147 if (compare_failed)
1148 {
1149 char *captured_char = buf_to_str(captured, (num_bits > 64) ? 64 : num_bits, 16);
1150 char *in_check_value_char = buf_to_str(field->in_check_value, (num_bits > 64) ? 64 : num_bits, 16);
1151
1152 if (field->in_check_mask)
1153 {
1154 char *in_check_mask_char;
1155 in_check_mask_char = buf_to_str(field->in_check_mask, (num_bits > 64) ? 64 : num_bits, 16);
1156 LOG_WARNING("value captured during scan didn't pass the requested check: captured: 0x%s check_value: 0x%s check_mask: 0x%s", captured_char, in_check_value_char, in_check_mask_char);
1157 free(in_check_mask_char);
1158 }
1159 else
1160 {
1161 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);
1162 }
1163
1164 free(captured_char);
1165 free(in_check_value_char);
1166
1167 retval = ERROR_JTAG_QUEUE_FAILED;
1168 }
1169
1170 }
1171 return retval;
1172 }
1173
1174 /*
1175 set up checking of this field using the in_handler. The values passed in must be valid until
1176 after jtag_execute() has completed.
1177 */
1178 void jtag_set_check_value(scan_field_t *field, u8 *value, u8 *mask, error_handler_t *in_error_handler)
1179 {
1180 if (value)
1181 field->in_handler = jtag_check_value;
1182 else
1183 field->in_handler = NULL; /* No check, e.g. embeddedice uses value==NULL to indicate no check */
1184 field->in_handler_priv = NULL; /* this will be filled in at the invocation site to point to the field duplicate */
1185 field->in_check_value = value;
1186 field->in_check_mask = mask;
1187 }
1188
1189 enum scan_type jtag_scan_type(scan_command_t *cmd)
1190 {
1191 int i;
1192 int type = 0;
1193
1194 for (i = 0; i < cmd->num_fields; i++)
1195 {
1196 if (cmd->fields[i].in_value || cmd->fields[i].in_handler)
1197 type |= SCAN_IN;
1198 if (cmd->fields[i].out_value)
1199 type |= SCAN_OUT;
1200 }
1201
1202 return type;
1203 }
1204
1205 int MINIDRIVER(interface_jtag_execute_queue)(void)
1206 {
1207 int retval;
1208
1209 retval = jtag->execute_queue();
1210
1211 cmd_queue_free();
1212
1213 jtag_command_queue = NULL;
1214 last_comand_pointer = &jtag_command_queue;
1215
1216 return retval;
1217 }
1218
1219 int jtag_execute_queue(void)
1220 {
1221 int retval=interface_jtag_execute_queue();
1222 if (retval==ERROR_OK)
1223 {
1224 retval=jtag_error;
1225 }
1226 jtag_error=ERROR_OK;
1227 return retval;
1228 }
1229
1230 int jtag_reset_callback(enum jtag_event event, void *priv)
1231 {
1232 jtag_device_t *device = priv;
1233
1234 LOG_DEBUG("-");
1235
1236 if (event == JTAG_TRST_ASSERTED)
1237 {
1238 buf_set_ones(device->cur_instr, device->ir_length);
1239 device->bypass = 1;
1240 }
1241
1242 return ERROR_OK;
1243 }
1244
1245 void jtag_sleep(u32 us)
1246 {
1247 usleep(us);
1248 }
1249
1250 /* Try to examine chain layout according to IEEE 1149.1 §12
1251 */
1252 int jtag_examine_chain()
1253 {
1254 jtag_device_t *device = jtag_devices;
1255 scan_field_t field;
1256 u8 idcode_buffer[JTAG_MAX_CHAIN_SIZE * 4];
1257 int i;
1258 int bit_count;
1259 int device_count = 0;
1260 u8 zero_check = 0x0;
1261 u8 one_check = 0xff;
1262
1263 field.device = 0;
1264 field.num_bits = sizeof(idcode_buffer) * 8;
1265 field.out_value = idcode_buffer;
1266 field.out_mask = NULL;
1267 field.in_value = idcode_buffer;
1268 field.in_check_value = NULL;
1269 field.in_check_mask = NULL;
1270 field.in_handler = NULL;
1271 field.in_handler_priv = NULL;
1272
1273 for (i = 0; i < JTAG_MAX_CHAIN_SIZE; i++)
1274 {
1275 buf_set_u32(idcode_buffer, i * 32, 32, 0x000000FF);
1276 }
1277
1278 jtag_add_plain_dr_scan(1, &field, TAP_TLR);
1279 jtag_execute_queue();
1280
1281 for (i = 0; i < JTAG_MAX_CHAIN_SIZE * 4; i++)
1282 {
1283 zero_check |= idcode_buffer[i];
1284 one_check &= idcode_buffer[i];
1285 }
1286
1287 /* if there wasn't a single non-zero bit or if all bits were one, the scan isn't valid */
1288 if ((zero_check == 0x00) || (one_check == 0xff))
1289 {
1290 LOG_ERROR("JTAG communication failure, check connection, JTAG interface, target power etc.");
1291 return ERROR_JTAG_INIT_FAILED;
1292 }
1293
1294 for (bit_count = 0; bit_count < (JTAG_MAX_CHAIN_SIZE * 32) - 31;)
1295 {
1296 u32 idcode = buf_get_u32(idcode_buffer, bit_count, 32);
1297 if ((idcode & 1) == 0)
1298 {
1299 /* LSB must not be 0, this indicates a device in bypass */
1300 device_count++;
1301
1302 bit_count += 1;
1303 }
1304 else
1305 {
1306 u32 manufacturer;
1307 u32 part;
1308 u32 version;
1309
1310 if (idcode == 0x000000FF)
1311 {
1312 /* End of chain (invalid manufacturer ID) */
1313 break;
1314 }
1315
1316 if (device)
1317 {
1318 device->idcode = idcode;
1319 device = device->next;
1320 }
1321 device_count++;
1322
1323 manufacturer = (idcode & 0xffe) >> 1;
1324 part = (idcode & 0xffff000) >> 12;
1325 version = (idcode & 0xf0000000) >> 28;
1326
1327 LOG_INFO("JTAG device found: 0x%8.8x (Manufacturer: 0x%3.3x, Part: 0x%4.4x, Version: 0x%1.1x)",
1328 idcode, manufacturer, part, version);
1329
1330 bit_count += 32;
1331 }
1332 }
1333
1334 /* see if number of discovered devices matches configuration */
1335 if (device_count != jtag_num_devices)
1336 {
1337 LOG_ERROR("number of discovered devices in JTAG chain (%i) doesn't match configuration (%i)",
1338 device_count, jtag_num_devices);
1339 LOG_ERROR("check the config file and ensure proper JTAG communication (connections, speed, ...)");
1340 return ERROR_JTAG_INIT_FAILED;
1341 }
1342
1343 return ERROR_OK;
1344 }
1345
1346 int jtag_validate_chain()
1347 {
1348 jtag_device_t *device = jtag_devices;
1349 int total_ir_length = 0;
1350 u8 *ir_test = NULL;
1351 scan_field_t field;
1352 int chain_pos = 0;
1353
1354 while (device)
1355 {
1356 total_ir_length += device->ir_length;
1357 device = device->next;
1358 }
1359
1360 total_ir_length += 2;
1361 ir_test = malloc(CEIL(total_ir_length, 8));
1362 buf_set_ones(ir_test, total_ir_length);
1363
1364 field.device = 0;
1365 field.num_bits = total_ir_length;
1366 field.out_value = ir_test;
1367 field.out_mask = NULL;
1368 field.in_value = ir_test;
1369 field.in_check_value = NULL;
1370 field.in_check_mask = NULL;
1371 field.in_handler = NULL;
1372 field.in_handler_priv = NULL;
1373
1374 jtag_add_plain_ir_scan(1, &field, TAP_TLR);
1375 jtag_execute_queue();
1376
1377 device = jtag_devices;
1378 while (device)
1379 {
1380 if (buf_get_u32(ir_test, chain_pos, 2) != 0x1)
1381 {
1382 char *cbuf = buf_to_str(ir_test, total_ir_length, 16);
1383 LOG_ERROR("Error validating JTAG scan chain, IR mismatch, scan returned 0x%s", cbuf);
1384 free(cbuf);
1385 free(ir_test);
1386 return ERROR_JTAG_INIT_FAILED;
1387 }
1388 chain_pos += device->ir_length;
1389 device = device->next;
1390 }
1391
1392 if (buf_get_u32(ir_test, chain_pos, 2) != 0x3)
1393 {
1394 char *cbuf = buf_to_str(ir_test, total_ir_length, 16);
1395 LOG_ERROR("Error validating JTAG scan chain, IR mismatch, scan returned 0x%s", cbuf);
1396 free(cbuf);
1397 free(ir_test);
1398 return ERROR_JTAG_INIT_FAILED;
1399 }
1400
1401 free(ir_test);
1402
1403 return ERROR_OK;
1404 }
1405
1406 int jtag_register_commands(struct command_context_s *cmd_ctx)
1407 {
1408 register_command(cmd_ctx, NULL, "interface", handle_interface_command,
1409 COMMAND_CONFIG, NULL);
1410 register_command(cmd_ctx, NULL, "jtag_speed", handle_jtag_speed_command,
1411 COMMAND_ANY, "set jtag speed (if supported) <reset speed> [<post reset speed, default value is reset speed>]");
1412 register_command(cmd_ctx, NULL, "jtag_khz", handle_jtag_khz_command,
1413 COMMAND_ANY, "same as jtag_speed, except it takes maximum khz as arguments. 0 KHz = RTCK.");
1414 register_command(cmd_ctx, NULL, "jtag_device", handle_jtag_device_command,
1415 COMMAND_CONFIG, "jtag_device <ir_length> <ir_expected> <ir_mask>");
1416 register_command(cmd_ctx, NULL, "reset_config", handle_reset_config_command,
1417 COMMAND_CONFIG, NULL);
1418 register_command(cmd_ctx, NULL, "jtag_nsrst_delay", handle_jtag_nsrst_delay_command,
1419 COMMAND_CONFIG, NULL);
1420 register_command(cmd_ctx, NULL, "jtag_ntrst_delay", handle_jtag_ntrst_delay_command,
1421 COMMAND_CONFIG, NULL);
1422
1423 register_command(cmd_ctx, NULL, "scan_chain", handle_scan_chain_command,
1424 COMMAND_EXEC, "print current scan chain configuration");
1425
1426 register_command(cmd_ctx, NULL, "endstate", handle_endstate_command,
1427 COMMAND_EXEC, "finish JTAG operations in <tap_state>");
1428 register_command(cmd_ctx, NULL, "jtag_reset", handle_jtag_reset_command,
1429 COMMAND_EXEC, "toggle reset lines <trst> <srst>");
1430 register_command(cmd_ctx, NULL, "runtest", handle_runtest_command,
1431 COMMAND_EXEC, "move to Run-Test/Idle, and execute <num_cycles>");
1432 register_command(cmd_ctx, NULL, "irscan", handle_irscan_command,
1433 COMMAND_EXEC, "execute IR scan <device> <instr> [dev2] [instr2] ...");
1434 register_command(cmd_ctx, NULL, "drscan", handle_drscan_command,
1435 COMMAND_EXEC, "execute DR scan <device> <var> [dev2] [var2] ...");
1436
1437 register_command(cmd_ctx, NULL, "verify_ircapture", handle_verify_ircapture_command,
1438 COMMAND_ANY, "verify value captured during Capture-IR <enable|disable>");
1439 return ERROR_OK;
1440 }
1441
1442 int jtag_interface_init(struct command_context_s *cmd_ctx)
1443 {
1444 if (!jtag_interface)
1445 {
1446 /* nothing was previously specified by "interface" command */
1447 LOG_ERROR("JTAG interface has to be specified, see \"interface\" command");
1448 return ERROR_JTAG_INVALID_INTERFACE;
1449 }
1450
1451 if (jtag_interface->init() != ERROR_OK)
1452 return ERROR_JTAG_INIT_FAILED;
1453
1454 jtag = jtag_interface;
1455 return ERROR_OK;
1456 }
1457
1458 int jtag_init(struct command_context_s *cmd_ctx)
1459 {
1460 int validate_tries = 0;
1461 jtag_device_t *device;
1462
1463 LOG_DEBUG("-");
1464
1465 if (!jtag && jtag_interface_init(cmd_ctx) != ERROR_OK)
1466 return ERROR_JTAG_INIT_FAILED;
1467
1468 device = jtag_devices;
1469 jtag_ir_scan_size = 0;
1470 jtag_num_devices = 0;
1471 while (device != NULL)
1472 {
1473 jtag_ir_scan_size += device->ir_length;
1474 jtag_num_devices++;
1475 device = device->next;
1476 }
1477
1478 jtag_add_tms();
1479 jtag_execute_queue();
1480
1481 /* examine chain first, as this could discover the real chain layout */
1482 if (jtag_examine_chain() != ERROR_OK)
1483 {
1484 LOG_ERROR("trying to validate configured JTAG chain anyway...");
1485 }
1486
1487 while (jtag_validate_chain() != ERROR_OK)
1488 {
1489 validate_tries++;
1490 if (validate_tries > 5)
1491 {
1492 LOG_ERROR("Could not validate JTAG chain, exit");
1493 return ERROR_JTAG_INVALID_INTERFACE;
1494 }
1495 usleep(10000);
1496 }
1497
1498 return ERROR_OK;
1499 }
1500
1501
1502 static int default_khz(int khz, int *jtag_speed)
1503 {
1504 LOG_ERROR("Translation from khz to jtag_speed not implemented");
1505 return ERROR_FAIL;
1506 }
1507
1508 int handle_interface_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1509 {
1510 int i;
1511
1512 /* check whether the interface is already configured */
1513 if (jtag_interface)
1514 {
1515 LOG_WARNING("Interface already configured, ignoring");
1516 return ERROR_OK;
1517 }
1518
1519 /* interface name is a mandatory argument */
1520 if (argc < 1 || args[0][0] == '\0')
1521 {
1522 return ERROR_COMMAND_SYNTAX_ERROR;
1523 }
1524
1525 for (i=0; jtag_interfaces[i]; i++)
1526 {
1527 if (strcmp(args[0], jtag_interfaces[i]->name) == 0)
1528 {
1529 if (jtag_interfaces[i]->register_commands(cmd_ctx) != ERROR_OK)
1530 exit(-1);
1531
1532 jtag_interface = jtag_interfaces[i];
1533
1534 if (jtag_interface->khz == NULL)
1535 {
1536 jtag_interface->khz = default_khz;
1537 }
1538 return ERROR_OK;
1539 }
1540 }
1541
1542 /* no valid interface was found (i.e. the configuration option,
1543 * didn't match one of the compiled-in interfaces
1544 */
1545 LOG_ERROR("No valid jtag interface found (%s)", args[0]);
1546 LOG_ERROR("compiled-in jtag interfaces:");
1547 for (i = 0; jtag_interfaces[i]; i++)
1548 {
1549 LOG_ERROR("%i: %s", i, jtag_interfaces[i]->name);
1550 }
1551
1552 return ERROR_JTAG_INVALID_INTERFACE;
1553 }
1554
1555 int handle_jtag_device_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1556 {
1557 jtag_device_t **last_device_p = &jtag_devices;
1558
1559 if (*last_device_p)
1560 {
1561 while ((*last_device_p)->next)
1562 last_device_p = &((*last_device_p)->next);
1563 last_device_p = &((*last_device_p)->next);
1564 }
1565
1566 if (argc < 3)
1567 return ERROR_OK;
1568
1569 *last_device_p = malloc(sizeof(jtag_device_t));
1570 (*last_device_p)->ir_length = strtoul(args[0], NULL, 0);
1571
1572 (*last_device_p)->expected = malloc((*last_device_p)->ir_length);
1573 buf_set_u32((*last_device_p)->expected, 0, (*last_device_p)->ir_length, strtoul(args[1], NULL, 0));
1574 (*last_device_p)->expected_mask = malloc((*last_device_p)->ir_length);
1575 buf_set_u32((*last_device_p)->expected_mask, 0, (*last_device_p)->ir_length, strtoul(args[2], NULL, 0));
1576
1577 (*last_device_p)->cur_instr = malloc((*last_device_p)->ir_length);
1578 (*last_device_p)->bypass = 1;
1579 buf_set_ones((*last_device_p)->cur_instr, (*last_device_p)->ir_length);
1580
1581 (*last_device_p)->next = NULL;
1582
1583 jtag_register_event_callback(jtag_reset_callback, (*last_device_p));
1584
1585 jtag_num_devices++;
1586
1587 return ERROR_OK;
1588 }
1589
1590 int handle_scan_chain_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1591 {
1592 jtag_device_t *device = jtag_devices;
1593 int device_count = 0;
1594
1595 while (device)
1596 {
1597 u32 expected, expected_mask, cur_instr;
1598 expected = buf_get_u32(device->expected, 0, device->ir_length);
1599 expected_mask = buf_get_u32(device->expected_mask, 0, device->ir_length);
1600 cur_instr = buf_get_u32(device->cur_instr, 0, device->ir_length);
1601 command_print(cmd_ctx, "%i: idcode: 0x%8.8x ir length %i, ir capture 0x%x, ir mask 0x%x, current instruction 0x%x", device_count, device->idcode, device->ir_length, expected, expected_mask, cur_instr);
1602 device = device->next;
1603 device_count++;
1604 }
1605
1606 return ERROR_OK;
1607 }
1608
1609 int handle_reset_config_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1610 {
1611 if (argc >= 1)
1612 {
1613 if (strcmp(args[0], "none") == 0)
1614 jtag_reset_config = RESET_NONE;
1615 else if (strcmp(args[0], "trst_only") == 0)
1616 jtag_reset_config = RESET_HAS_TRST;
1617 else if (strcmp(args[0], "srst_only") == 0)
1618 jtag_reset_config = RESET_HAS_SRST;
1619 else if (strcmp(args[0], "trst_and_srst") == 0)
1620 jtag_reset_config = RESET_TRST_AND_SRST;
1621 else
1622 {
1623 LOG_ERROR("invalid reset_config argument, defaulting to none");
1624 jtag_reset_config = RESET_NONE;
1625 return ERROR_INVALID_ARGUMENTS;
1626 }
1627 }
1628
1629 if (argc >= 2)
1630 {
1631 if (strcmp(args[1], "srst_pulls_trst") == 0)
1632 jtag_reset_config |= RESET_SRST_PULLS_TRST;
1633 else if (strcmp(args[1], "trst_pulls_srst") == 0)
1634 jtag_reset_config |= RESET_TRST_PULLS_SRST;
1635 else if (strcmp(args[1], "combined") == 0)
1636 jtag_reset_config |= RESET_SRST_PULLS_TRST | RESET_TRST_PULLS_SRST;
1637 else if (strcmp(args[1], "separate") == 0)
1638 jtag_reset_config &= ~(RESET_SRST_PULLS_TRST | RESET_TRST_PULLS_SRST);
1639 else
1640 {
1641 LOG_ERROR("invalid reset_config argument, defaulting to none");
1642 jtag_reset_config = RESET_NONE;
1643 return ERROR_INVALID_ARGUMENTS;
1644 }
1645 }
1646
1647 if (argc >= 3)
1648 {
1649 if (strcmp(args[2], "trst_open_drain") == 0)
1650 jtag_reset_config |= RESET_TRST_OPEN_DRAIN;
1651 else if (strcmp(args[2], "trst_push_pull") == 0)
1652 jtag_reset_config &= ~RESET_TRST_OPEN_DRAIN;
1653 else
1654 {
1655 LOG_ERROR("invalid reset_config argument, defaulting to none");
1656 jtag_reset_config = RESET_NONE;
1657 return ERROR_INVALID_ARGUMENTS;
1658 }
1659 }
1660
1661 if (argc >= 4)
1662 {
1663 if (strcmp(args[3], "srst_push_pull") == 0)
1664 jtag_reset_config |= RESET_SRST_PUSH_PULL;
1665 else if (strcmp(args[3], "srst_open_drain") == 0)
1666 jtag_reset_config &= ~RESET_SRST_PUSH_PULL;
1667 else
1668 {
1669 LOG_ERROR("invalid reset_config argument, defaulting to none");
1670 jtag_reset_config = RESET_NONE;
1671 return ERROR_INVALID_ARGUMENTS;
1672 }
1673 }
1674
1675 return ERROR_OK;
1676 }
1677
1678 int handle_jtag_nsrst_delay_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1679 {
1680 if (argc < 1)
1681 {
1682 LOG_ERROR("jtag_nsrst_delay <ms> command takes one required argument");
1683 exit(-1);
1684 }
1685 else
1686 {
1687 jtag_nsrst_delay = strtoul(args[0], NULL, 0);
1688 }
1689
1690 return ERROR_OK;
1691 }
1692
1693 int handle_jtag_ntrst_delay_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1694 {
1695 if (argc < 1)
1696 {
1697 LOG_ERROR("jtag_ntrst_delay <ms> command takes one required argument");
1698 exit(-1);
1699 }
1700 else
1701 {
1702 jtag_ntrst_delay = strtoul(args[0], NULL, 0);
1703 }
1704
1705 return ERROR_OK;
1706 }
1707
1708 int handle_jtag_speed_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1709 {
1710 int cur_speed = 0;
1711 if ((argc<1) || (argc>2))
1712 return ERROR_COMMAND_SYNTAX_ERROR;
1713
1714 if (argc >= 1)
1715 cur_speed = jtag_speed = jtag_speed_post_reset = strtoul(args[0], NULL, 0);
1716 if (argc == 2)
1717 cur_speed = jtag_speed_post_reset = strtoul(args[1], NULL, 0);
1718
1719 /* this command can be called during CONFIG,
1720 * in which case jtag isn't initialized */
1721 if (jtag)
1722 jtag->speed(cur_speed);
1723
1724 return ERROR_OK;
1725 }
1726
1727 int handle_jtag_khz_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1728 {
1729 int cur_speed = 0;
1730 int speed1, speed2;
1731 if ((argc<1) || (argc>2))
1732 return ERROR_COMMAND_SYNTAX_ERROR;
1733
1734 if (jtag == NULL)
1735 {
1736 LOG_ERROR("Interface not selected yet");
1737 return ERROR_COMMAND_SYNTAX_ERROR;
1738 }
1739
1740 if (argc >= 1)
1741 speed1 = strtoul(args[0], NULL, 0);
1742 if (argc == 2)
1743 speed2 = strtoul(args[1], NULL, 0);
1744
1745 if (jtag->khz(speed1, &speed1)!=ERROR_OK)
1746 return ERROR_OK;
1747
1748 if (jtag->khz(speed2, &speed2)!=ERROR_OK)
1749 return ERROR_OK;
1750
1751 if (argc >= 1)
1752 cur_speed = jtag_speed = jtag_speed_post_reset = speed1;
1753
1754 if (argc == 2)
1755 cur_speed = jtag_speed_post_reset = speed2;
1756
1757 jtag->speed(cur_speed);
1758
1759 return ERROR_OK;
1760 }
1761
1762
1763 int handle_endstate_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1764 {
1765 enum tap_state state;
1766
1767 if (argc < 1)
1768 {
1769 return ERROR_COMMAND_SYNTAX_ERROR;
1770 }
1771 else
1772 {
1773 for (state = 0; state < 16; state++)
1774 {
1775 if (strcmp(args[0], tap_state_strings[state]) == 0)
1776 {
1777 jtag_add_end_state(state);
1778 jtag_execute_queue();
1779 }
1780 }
1781 }
1782 command_print(cmd_ctx, "current endstate: %s", tap_state_strings[end_state]);
1783
1784 return ERROR_OK;
1785 }
1786
1787 int handle_jtag_reset_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1788 {
1789 int trst = -1;
1790 int srst = -1;
1791
1792 if (argc < 2)
1793 {
1794 return ERROR_COMMAND_SYNTAX_ERROR;
1795 }
1796
1797 if (args[0][0] == '1')
1798 trst = 1;
1799 else if (args[0][0] == '0')
1800 trst = 0;
1801 else
1802 {
1803 return ERROR_COMMAND_SYNTAX_ERROR;
1804 }
1805
1806 if (args[1][0] == '1')
1807 srst = 1;
1808 else if (args[1][0] == '0')
1809 srst = 0;
1810 else
1811 {
1812 return ERROR_COMMAND_SYNTAX_ERROR;
1813 }
1814
1815 if (!jtag && jtag_interface_init(cmd_ctx) != ERROR_OK)
1816 return ERROR_JTAG_INIT_FAILED;
1817
1818 jtag_add_reset(trst, srst);
1819 jtag_execute_queue();
1820
1821 return ERROR_OK;
1822 }
1823
1824 int handle_runtest_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1825 {
1826 if (argc < 1)
1827 {
1828 return ERROR_COMMAND_SYNTAX_ERROR;
1829 }
1830
1831 jtag_add_runtest(strtol(args[0], NULL, 0), -1);
1832 jtag_execute_queue();
1833
1834 return ERROR_OK;
1835
1836 }
1837
1838
1839 int handle_irscan_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1840 {
1841 int i;
1842 scan_field_t *fields;
1843
1844 if ((argc < 2) || (argc % 2))
1845 {
1846 return ERROR_COMMAND_SYNTAX_ERROR;
1847 }
1848
1849 fields = malloc(sizeof(scan_field_t) * argc / 2);
1850
1851 for (i = 0; i < argc / 2; i++)
1852 {
1853 int device = strtoul(args[i*2], NULL, 0);
1854 int field_size = jtag_get_device(device)->ir_length;
1855 fields[i].device = device;
1856 fields[i].out_value = malloc(CEIL(field_size, 8));
1857 buf_set_u32(fields[i].out_value, 0, field_size, strtoul(args[i*2+1], NULL, 0));
1858 fields[i].out_mask = NULL;
1859 fields[i].in_value = NULL;
1860 fields[i].in_check_mask = NULL;
1861 fields[i].in_handler = NULL;
1862 fields[i].in_handler_priv = NULL;
1863 }
1864
1865 jtag_add_ir_scan(argc / 2, fields, -1);
1866 jtag_execute_queue();
1867
1868 for (i = 0; i < argc / 2; i++)
1869 free(fields[i].out_value);
1870
1871 free (fields);
1872
1873 return ERROR_OK;
1874 }
1875
1876 int handle_drscan_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1877 {
1878 scan_field_t *fields;
1879 int num_fields = 0;
1880 int field_count = 0;
1881 var_t *var;
1882 int i, j;
1883
1884 if ((argc < 2) || (argc % 2))
1885 {
1886 return ERROR_COMMAND_SYNTAX_ERROR;
1887 }
1888
1889 for (i = 0; i < argc; i+=2)
1890 {
1891 var = get_var_by_namenum(args[i+1]);
1892 if (var)
1893 {
1894 num_fields += var->num_fields;
1895 }
1896 else
1897 {
1898 command_print(cmd_ctx, "variable %s doesn't exist", args[i+1]);
1899 return ERROR_OK;
1900 }
1901 }
1902
1903 fields = malloc(sizeof(scan_field_t) * num_fields);
1904
1905 for (i = 0; i < argc; i+=2)
1906 {
1907 var = get_var_by_namenum(args[i+1]);
1908
1909 for (j = 0; j < var->num_fields; j++)
1910 {
1911 fields[field_count].device = strtol(args[i], NULL, 0);
1912 fields[field_count].num_bits = var->fields[j].num_bits;
1913 fields[field_count].out_value = malloc(CEIL(var->fields[j].num_bits, 8));
1914 buf_set_u32(fields[field_count].out_value, 0, var->fields[j].num_bits, var->fields[j].value);
1915 fields[field_count].out_mask = NULL;
1916 fields[field_count].in_value = fields[field_count].out_value;
1917 fields[field_count].in_check_mask = NULL;
1918 fields[field_count].in_check_value = NULL;
1919 fields[field_count].in_handler = field_le_to_host;
1920 fields[field_count++].in_handler_priv = &(var->fields[j]);
1921 }
1922 }
1923
1924 jtag_add_dr_scan(num_fields, fields, -1);
1925 jtag_execute_queue();
1926
1927 for (i = 0; i < argc / 2; i++)
1928 free(fields[i].out_value);
1929
1930 free(fields);
1931
1932 return ERROR_OK;
1933 }
1934
1935 int handle_verify_ircapture_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1936 {
1937 if (argc == 1)
1938 {
1939 if (strcmp(args[0], "enable") == 0)
1940 {
1941 jtag_verify_capture_ir = 1;
1942 }
1943 else if (strcmp(args[0], "disable") == 0)
1944 {
1945 jtag_verify_capture_ir = 0;
1946 } else
1947 {
1948 return ERROR_COMMAND_SYNTAX_ERROR;
1949 }
1950 } else if (argc != 0)
1951 {
1952 return ERROR_COMMAND_SYNTAX_ERROR;
1953 }
1954
1955 command_print(cmd_ctx, "verify Capture-IR is %s", (jtag_verify_capture_ir) ? "enabled": "disabled");
1956
1957 return ERROR_OK;
1958 }
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)