Code Review / openocd.git / blob
? search:
summary | shortlog | log | commit | commitdiff | review | tree
history | raw | HEAD
TAP_SD/SI are now forbidden end states.
[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_statemove(enum tap_state endstate);
226 void jtag_add_pathmove(int num_states, enum tap_state *path);
227 void jtag_add_runtest(int num_cycles, enum tap_state endstate);
228 void jtag_add_reset(int trst, int srst);
229 void jtag_add_end_state(enum tap_state endstate);
230 void jtag_add_sleep(u32 us);
231 int jtag_execute_queue(void);
232 int jtag_cancel_queue(void);
233
234 /* jtag commands */
235 int handle_interface_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
236 int handle_jtag_speed_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
237 int handle_jtag_khz_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
238 int handle_jtag_device_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
239 int handle_reset_config_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
240 int handle_jtag_nsrst_delay_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
241 int handle_jtag_ntrst_delay_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
242
243 int handle_scan_chain_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
244
245 int handle_endstate_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
246 int handle_jtag_reset_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
247 int handle_runtest_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
248 int handle_statemove_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
249 int handle_irscan_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
250 int handle_drscan_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
251
252 int handle_verify_ircapture_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
253
254 int jtag_register_event_callback(int (*callback)(enum jtag_event event, void *priv), void *priv)
255 {
256 jtag_event_callback_t **callbacks_p = &jtag_event_callbacks;
257
258 if (callback == NULL)
259 {
260 return ERROR_INVALID_ARGUMENTS;
261 }
262
263 if (*callbacks_p)
264 {
265 while ((*callbacks_p)->next)
266 callbacks_p = &((*callbacks_p)->next);
267 callbacks_p = &((*callbacks_p)->next);
268 }
269
270 (*callbacks_p) = malloc(sizeof(jtag_event_callback_t));
271 (*callbacks_p)->callback = callback;
272 (*callbacks_p)->priv = priv;
273 (*callbacks_p)->next = NULL;
274
275 return ERROR_OK;
276 }
277
278 int jtag_unregister_event_callback(int (*callback)(enum jtag_event event, void *priv))
279 {
280 jtag_event_callback_t **callbacks_p = &jtag_event_callbacks;
281
282 if (callback == NULL)
283 {
284 return ERROR_INVALID_ARGUMENTS;
285 }
286
287 while (*callbacks_p)
288 {
289 jtag_event_callback_t **next = &((*callbacks_p)->next);
290 if ((*callbacks_p)->callback == callback)
291 {
292 free(*callbacks_p);
293 *callbacks_p = *next;
294 }
295 callbacks_p = next;
296 }
297
298 return ERROR_OK;
299 }
300
301 int jtag_call_event_callbacks(enum jtag_event event)
302 {
303 jtag_event_callback_t *callback = jtag_event_callbacks;
304
305 LOG_DEBUG("jtag event: %s", jtag_event_strings[event]);
306
307 while (callback)
308 {
309 callback->callback(event, callback->priv);
310 callback = callback->next;
311 }
312
313 return ERROR_OK;
314 }
315
316 /* returns a pointer to the pointer of the last command in queue
317 * this may be a pointer to the root pointer (jtag_command_queue)
318 * or to the next member of the last but one command
319 */
320 jtag_command_t** jtag_get_last_command_p(void)
321 {
322 /* jtag_command_t *cmd = jtag_command_queue;
323
324 if (cmd)
325 while (cmd->next)
326 cmd = cmd->next;
327 else
328 return &jtag_command_queue;
329
330 return &cmd->next;*/
331
332 return last_comand_pointer;
333 }
334
335 /* returns a pointer to the n-th device in the scan chain */
336 jtag_device_t* jtag_get_device(int num)
337 {
338 jtag_device_t *device = jtag_devices;
339 int i = 0;
340
341 while (device)
342 {
343 if (num == i)
344 return device;
345 device = device->next;
346 i++;
347 }
348
349 LOG_ERROR("jtag device number %d not defined", num);
350 exit(-1);
351 }
352
353 void* cmd_queue_alloc(size_t size)
354 {
355 cmd_queue_page_t **p_page = &cmd_queue_pages;
356 int offset;
357
358 if (*p_page)
359 {
360 while ((*p_page)->next)
361 p_page = &((*p_page)->next);
362 if (CMD_QUEUE_PAGE_SIZE - (*p_page)->used < size)
363 p_page = &((*p_page)->next);
364 }
365
366 if (!*p_page)
367 {
368 *p_page = malloc(sizeof(cmd_queue_page_t));
369 (*p_page)->used = 0;
370 (*p_page)->address = malloc(CMD_QUEUE_PAGE_SIZE);
371 (*p_page)->next = NULL;
372 }
373
374 offset = (*p_page)->used;
375 (*p_page)->used += size;
376
377 u8 *t=(u8 *)((*p_page)->address);
378 return t + offset;
379 }
380
381 void cmd_queue_free()
382 {
383 cmd_queue_page_t *page = cmd_queue_pages;
384
385 while (page)
386 {
387 cmd_queue_page_t *last = page;
388 free(page->address);
389 page = page->next;
390 free(last);
391 }
392
393 cmd_queue_pages = NULL;
394 }
395
396 static void jtag_prelude1()
397 {
398 if (jtag_trst == 1)
399 {
400 LOG_WARNING("JTAG command queued, while TRST is low (TAP in reset)");
401 jtag_error=ERROR_JTAG_TRST_ASSERTED;
402 return;
403 }
404
405 if (cmd_queue_end_state == TAP_TLR)
406 jtag_call_event_callbacks(JTAG_TRST_ASSERTED);
407 }
408
409 static void jtag_prelude(enum tap_state state)
410 {
411 jtag_prelude1();
412
413 if (state != -1)
414 jtag_add_end_state(state);
415
416 cmd_queue_cur_state = cmd_queue_end_state;
417 }
418
419 void jtag_add_ir_scan(int num_fields, scan_field_t *fields, enum tap_state state)
420 {
421 jtag_prelude(state);
422
423 int retval=interface_jtag_add_ir_scan(num_fields, fields, cmd_queue_end_state);
424 if (retval!=ERROR_OK)
425 jtag_error=retval;
426 }
427
428 int MINIDRIVER(interface_jtag_add_ir_scan)(int num_fields, scan_field_t *fields, enum tap_state state)
429 {
430 jtag_command_t **last_cmd;
431 jtag_device_t *device;
432 int i, j;
433 int scan_size = 0;
434
435
436 last_cmd = jtag_get_last_command_p();
437
438 /* allocate memory for a new list member */
439 *last_cmd = cmd_queue_alloc(sizeof(jtag_command_t));
440 (*last_cmd)->next = NULL;
441 last_comand_pointer = &((*last_cmd)->next);
442 (*last_cmd)->type = JTAG_SCAN;
443
444 /* allocate memory for ir scan command */
445 (*last_cmd)->cmd.scan = cmd_queue_alloc(sizeof(scan_command_t));
446 (*last_cmd)->cmd.scan->ir_scan = 1;
447 (*last_cmd)->cmd.scan->num_fields = jtag_num_devices; /* one field per device */
448 (*last_cmd)->cmd.scan->fields = cmd_queue_alloc(jtag_num_devices * sizeof(scan_field_t));
449 (*last_cmd)->cmd.scan->end_state = state;
450
451 for (i = 0; i < jtag_num_devices; i++)
452 {
453 int found = 0;
454 device = jtag_get_device(i);
455 scan_size = device->ir_length;
456 (*last_cmd)->cmd.scan->fields[i].device = i;
457 (*last_cmd)->cmd.scan->fields[i].num_bits = scan_size;
458 (*last_cmd)->cmd.scan->fields[i].in_value = NULL;
459 (*last_cmd)->cmd.scan->fields[i].in_handler = NULL; /* disable verification by default */
460
461 /* search the list */
462 for (j = 0; j < num_fields; j++)
463 {
464 if (i == fields[j].device)
465 {
466 found = 1;
467 (*last_cmd)->cmd.scan->fields[i].out_value = buf_cpy(fields[j].out_value, cmd_queue_alloc(CEIL(scan_size, 8)), scan_size);
468 (*last_cmd)->cmd.scan->fields[i].out_mask = buf_cpy(fields[j].out_mask, cmd_queue_alloc(CEIL(scan_size, 8)), scan_size);
469
470 if (jtag_verify_capture_ir)
471 {
472 if (fields[j].in_handler==NULL)
473 {
474 jtag_set_check_value((*last_cmd)->cmd.scan->fields+i, device->expected, device->expected_mask, NULL);
475 } else
476 {
477 (*last_cmd)->cmd.scan->fields[i].in_handler = fields[j].in_handler;
478 (*last_cmd)->cmd.scan->fields[i].in_handler_priv = fields[j].in_handler_priv;
479 (*last_cmd)->cmd.scan->fields[i].in_check_value = device->expected;
480 (*last_cmd)->cmd.scan->fields[i].in_check_mask = device->expected_mask;
481 }
482 }
483
484 device->bypass = 0;
485 break;
486 }
487 }
488
489 if (!found)
490 {
491 /* if a device isn't listed, set it to BYPASS */
492 (*last_cmd)->cmd.scan->fields[i].out_value = buf_set_ones(cmd_queue_alloc(CEIL(scan_size, 8)), scan_size);
493 (*last_cmd)->cmd.scan->fields[i].out_mask = NULL;
494 device->bypass = 1;
495
496 }
497
498 /* update device information */
499 buf_cpy((*last_cmd)->cmd.scan->fields[i].out_value, jtag_get_device(i)->cur_instr, scan_size);
500 }
501
502 return ERROR_OK;
503 }
504
505 void jtag_add_plain_ir_scan(int num_fields, scan_field_t *fields, enum tap_state state)
506 {
507 jtag_prelude(state);
508
509 int retval=interface_jtag_add_plain_ir_scan(num_fields, fields, cmd_queue_end_state);
510 if (retval!=ERROR_OK)
511 jtag_error=retval;
512 }
513
514 int MINIDRIVER(interface_jtag_add_plain_ir_scan)(int num_fields, scan_field_t *fields, enum tap_state state)
515 {
516 int i;
517 jtag_command_t **last_cmd;
518
519 last_cmd = jtag_get_last_command_p();
520
521 /* allocate memory for a new list member */
522 *last_cmd = cmd_queue_alloc(sizeof(jtag_command_t));
523 (*last_cmd)->next = NULL;
524 last_comand_pointer = &((*last_cmd)->next);
525 (*last_cmd)->type = JTAG_SCAN;
526
527 /* allocate memory for ir scan command */
528 (*last_cmd)->cmd.scan = cmd_queue_alloc(sizeof(scan_command_t));
529 (*last_cmd)->cmd.scan->ir_scan = 1;
530 (*last_cmd)->cmd.scan->num_fields = num_fields;
531 (*last_cmd)->cmd.scan->fields = cmd_queue_alloc(num_fields * sizeof(scan_field_t));
532 (*last_cmd)->cmd.scan->end_state = state;
533
534 for (i = 0; i < num_fields; i++)
535 {
536 int num_bits = fields[i].num_bits;
537 int num_bytes = CEIL(fields[i].num_bits, 8);
538 (*last_cmd)->cmd.scan->fields[i].device = fields[i].device;
539 (*last_cmd)->cmd.scan->fields[i].num_bits = num_bits;
540 (*last_cmd)->cmd.scan->fields[i].out_value = buf_cpy(fields[i].out_value, cmd_queue_alloc(num_bytes), num_bits);
541 (*last_cmd)->cmd.scan->fields[i].out_mask = buf_cpy(fields[i].out_mask, cmd_queue_alloc(num_bytes), num_bits);
542 (*last_cmd)->cmd.scan->fields[i].in_value = fields[i].in_value;
543 (*last_cmd)->cmd.scan->fields[i].in_check_value = fields[i].in_check_value;
544 (*last_cmd)->cmd.scan->fields[i].in_check_mask = fields[i].in_check_mask;
545 (*last_cmd)->cmd.scan->fields[i].in_handler = NULL;
546 (*last_cmd)->cmd.scan->fields[i].in_handler_priv = NULL;
547 }
548 return ERROR_OK;
549 }
550
551 void jtag_add_dr_scan(int num_fields, scan_field_t *fields, enum tap_state state)
552 {
553 jtag_prelude(state);
554
555 int retval=interface_jtag_add_dr_scan(num_fields, fields, cmd_queue_end_state);
556 if (retval!=ERROR_OK)
557 jtag_error=retval;
558 }
559
560 int MINIDRIVER(interface_jtag_add_dr_scan)(int num_fields, scan_field_t *fields, enum tap_state state)
561 {
562 int i, j;
563 int bypass_devices = 0;
564 int field_count = 0;
565 int scan_size;
566
567 jtag_command_t **last_cmd = jtag_get_last_command_p();
568 jtag_device_t *device = jtag_devices;
569
570 /* count devices in bypass */
571 while (device)
572 {
573 if (device->bypass)
574 bypass_devices++;
575 device = device->next;
576 }
577
578 /* allocate memory for a new list member */
579 *last_cmd = cmd_queue_alloc(sizeof(jtag_command_t));
580 last_comand_pointer = &((*last_cmd)->next);
581 (*last_cmd)->next = NULL;
582 (*last_cmd)->type = JTAG_SCAN;
583
584 /* allocate memory for dr scan command */
585 (*last_cmd)->cmd.scan = cmd_queue_alloc(sizeof(scan_command_t));
586 (*last_cmd)->cmd.scan->ir_scan = 0;
587 (*last_cmd)->cmd.scan->num_fields = num_fields + bypass_devices;
588 (*last_cmd)->cmd.scan->fields = cmd_queue_alloc((num_fields + bypass_devices) * sizeof(scan_field_t));
589 (*last_cmd)->cmd.scan->end_state = state;
590
591 for (i = 0; i < jtag_num_devices; i++)
592 {
593 int found = 0;
594 (*last_cmd)->cmd.scan->fields[field_count].device = i;
595
596 for (j = 0; j < num_fields; j++)
597 {
598 if (i == fields[j].device)
599 {
600 found = 1;
601 scan_size = fields[j].num_bits;
602 (*last_cmd)->cmd.scan->fields[field_count].num_bits = scan_size;
603 (*last_cmd)->cmd.scan->fields[field_count].out_value = buf_cpy(fields[j].out_value, cmd_queue_alloc(CEIL(scan_size, 8)), scan_size);
604 (*last_cmd)->cmd.scan->fields[field_count].out_mask = buf_cpy(fields[j].out_mask, cmd_queue_alloc(CEIL(scan_size, 8)), scan_size);
605 (*last_cmd)->cmd.scan->fields[field_count].in_value = fields[j].in_value;
606 (*last_cmd)->cmd.scan->fields[field_count].in_check_value = fields[j].in_check_value;
607 (*last_cmd)->cmd.scan->fields[field_count].in_check_mask = fields[j].in_check_mask;
608 (*last_cmd)->cmd.scan->fields[field_count].in_handler = fields[j].in_handler;
609 (*last_cmd)->cmd.scan->fields[field_count++].in_handler_priv = fields[j].in_handler_priv;
610 }
611 }
612 if (!found)
613 {
614 #ifdef _DEBUG_JTAG_IO_
615 /* if a device isn't listed, the BYPASS register should be selected */
616 if (!jtag_get_device(i)->bypass)
617 {
618 LOG_ERROR("BUG: no scan data for a device not in BYPASS");
619 exit(-1);
620 }
621 #endif
622 /* program the scan field to 1 bit length, and ignore it's value */
623 (*last_cmd)->cmd.scan->fields[field_count].num_bits = 1;
624 (*last_cmd)->cmd.scan->fields[field_count].out_value = NULL;
625 (*last_cmd)->cmd.scan->fields[field_count].out_mask = NULL;
626 (*last_cmd)->cmd.scan->fields[field_count].in_value = NULL;
627 (*last_cmd)->cmd.scan->fields[field_count].in_check_value = NULL;
628 (*last_cmd)->cmd.scan->fields[field_count].in_check_mask = NULL;
629 (*last_cmd)->cmd.scan->fields[field_count].in_handler = NULL;
630 (*last_cmd)->cmd.scan->fields[field_count++].in_handler_priv = NULL;
631 }
632 else
633 {
634 #ifdef _DEBUG_JTAG_IO_
635 /* if a device is listed, the BYPASS register must not be selected */
636 if (jtag_get_device(i)->bypass)
637 {
638 LOG_ERROR("BUG: scan data for a device in BYPASS");
639 exit(-1);
640 }
641 #endif
642 }
643 }
644 return ERROR_OK;
645 }
646
647 void MINIDRIVER(interface_jtag_add_dr_out)(int device_num,
648 int num_fields,
649 int *num_bits,
650 u32 *value,
651 enum tap_state end_state)
652 {
653 int i;
654 int field_count = 0;
655 int scan_size;
656 int bypass_devices = 0;
657
658 jtag_command_t **last_cmd = jtag_get_last_command_p();
659 jtag_device_t *device = jtag_devices;
660 /* count devices in bypass */
661 while (device)
662 {
663 if (device->bypass)
664 bypass_devices++;
665 device = device->next;
666 }
667
668 /* allocate memory for a new list member */
669 *last_cmd = cmd_queue_alloc(sizeof(jtag_command_t));
670 last_comand_pointer = &((*last_cmd)->next);
671 (*last_cmd)->next = NULL;
672 (*last_cmd)->type = JTAG_SCAN;
673
674 /* allocate memory for dr scan command */
675 (*last_cmd)->cmd.scan = cmd_queue_alloc(sizeof(scan_command_t));
676 (*last_cmd)->cmd.scan->ir_scan = 0;
677 (*last_cmd)->cmd.scan->num_fields = num_fields + bypass_devices;
678 (*last_cmd)->cmd.scan->fields = cmd_queue_alloc((num_fields + bypass_devices) * sizeof(scan_field_t));
679 (*last_cmd)->cmd.scan->end_state = end_state;
680
681 for (i = 0; i < jtag_num_devices; i++)
682 {
683 (*last_cmd)->cmd.scan->fields[field_count].device = i;
684
685 if (i == device_num)
686 {
687 int j;
688 #ifdef _DEBUG_JTAG_IO_
689 /* if a device is listed, the BYPASS register must not be selected */
690 if (jtag_get_device(i)->bypass)
691 {
692 LOG_ERROR("BUG: scan data for a device in BYPASS");
693 exit(-1);
694 }
695 #endif
696 for (j = 0; j < num_fields; j++)
697 {
698 u8 out_value[4];
699 scan_size = num_bits[j];
700 buf_set_u32(out_value, 0, scan_size, value[j]);
701 (*last_cmd)->cmd.scan->fields[field_count].num_bits = scan_size;
702 (*last_cmd)->cmd.scan->fields[field_count].out_value = buf_cpy(out_value, cmd_queue_alloc(CEIL(scan_size, 8)), scan_size);
703 (*last_cmd)->cmd.scan->fields[field_count].out_mask = NULL;
704 (*last_cmd)->cmd.scan->fields[field_count].in_value = NULL;
705 (*last_cmd)->cmd.scan->fields[field_count].in_check_value = NULL;
706 (*last_cmd)->cmd.scan->fields[field_count].in_check_mask = NULL;
707 (*last_cmd)->cmd.scan->fields[field_count].in_handler = NULL;
708 (*last_cmd)->cmd.scan->fields[field_count++].in_handler_priv = NULL;
709 }
710 } else
711 {
712 #ifdef _DEBUG_JTAG_IO_
713 /* if a device isn't listed, the BYPASS register should be selected */
714 if (!jtag_get_device(i)->bypass)
715 {
716 LOG_ERROR("BUG: no scan data for a device not in BYPASS");
717 exit(-1);
718 }
719 #endif
720 /* program the scan field to 1 bit length, and ignore it's value */
721 (*last_cmd)->cmd.scan->fields[field_count].num_bits = 1;
722 (*last_cmd)->cmd.scan->fields[field_count].out_value = NULL;
723 (*last_cmd)->cmd.scan->fields[field_count].out_mask = NULL;
724 (*last_cmd)->cmd.scan->fields[field_count].in_value = NULL;
725 (*last_cmd)->cmd.scan->fields[field_count].in_check_value = NULL;
726 (*last_cmd)->cmd.scan->fields[field_count].in_check_mask = NULL;
727 (*last_cmd)->cmd.scan->fields[field_count].in_handler = NULL;
728 (*last_cmd)->cmd.scan->fields[field_count++].in_handler_priv = NULL;
729 }
730 }
731 }
732
733
734
735
736 void jtag_add_plain_dr_scan(int num_fields, scan_field_t *fields, enum tap_state state)
737 {
738 jtag_prelude(state);
739
740 int retval=interface_jtag_add_plain_dr_scan(num_fields, fields, cmd_queue_end_state);
741 if (retval!=ERROR_OK)
742 jtag_error=retval;
743 }
744
745 int MINIDRIVER(interface_jtag_add_plain_dr_scan)(int num_fields, scan_field_t *fields, enum tap_state state)
746 {
747 int i;
748 jtag_command_t **last_cmd = jtag_get_last_command_p();
749
750 /* allocate memory for a new list member */
751 *last_cmd = cmd_queue_alloc(sizeof(jtag_command_t));
752 last_comand_pointer = &((*last_cmd)->next);
753 (*last_cmd)->next = NULL;
754 (*last_cmd)->type = JTAG_SCAN;
755
756 /* allocate memory for scan command */
757 (*last_cmd)->cmd.scan = cmd_queue_alloc(sizeof(scan_command_t));
758 (*last_cmd)->cmd.scan->ir_scan = 0;
759 (*last_cmd)->cmd.scan->num_fields = num_fields;
760 (*last_cmd)->cmd.scan->fields = cmd_queue_alloc(num_fields * sizeof(scan_field_t));
761 (*last_cmd)->cmd.scan->end_state = state;
762
763 for (i = 0; i < num_fields; i++)
764 {
765 int num_bits = fields[i].num_bits;
766 int num_bytes = CEIL(fields[i].num_bits, 8);
767 (*last_cmd)->cmd.scan->fields[i].device = fields[i].device;
768 (*last_cmd)->cmd.scan->fields[i].num_bits = num_bits;
769 (*last_cmd)->cmd.scan->fields[i].out_value = buf_cpy(fields[i].out_value, cmd_queue_alloc(num_bytes), num_bits);
770 (*last_cmd)->cmd.scan->fields[i].out_mask = buf_cpy(fields[i].out_mask, cmd_queue_alloc(num_bytes), num_bits);
771 (*last_cmd)->cmd.scan->fields[i].in_value = fields[i].in_value;
772 (*last_cmd)->cmd.scan->fields[i].in_check_value = fields[i].in_check_value;
773 (*last_cmd)->cmd.scan->fields[i].in_check_mask = fields[i].in_check_mask;
774 (*last_cmd)->cmd.scan->fields[i].in_handler = fields[i].in_handler;
775 (*last_cmd)->cmd.scan->fields[i].in_handler_priv = fields[i].in_handler_priv;
776 }
777
778 return ERROR_OK;
779 }
780 void jtag_add_statemove(enum tap_state state)
781 {
782 jtag_prelude(state);
783
784 int retval;
785 retval=interface_jtag_add_statemove(cmd_queue_end_state);
786 if (retval!=ERROR_OK)
787 jtag_error=retval;
788 }
789
790 int MINIDRIVER(interface_jtag_add_statemove)(enum tap_state state)
791 {
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_statemove(TAP_TLR);
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, "statemove", handle_statemove_command,
1433 COMMAND_EXEC, "move to current endstate or [tap_state]");
1434 register_command(cmd_ctx, NULL, "irscan", handle_irscan_command,
1435 COMMAND_EXEC, "execute IR scan <device> <instr> [dev2] [instr2] ...");
1436 register_command(cmd_ctx, NULL, "drscan", handle_drscan_command,
1437 COMMAND_EXEC, "execute DR scan <device> <var> [dev2] [var2] ...");
1438
1439 register_command(cmd_ctx, NULL, "verify_ircapture", handle_verify_ircapture_command,
1440 COMMAND_ANY, "verify value captured during Capture-IR <enable|disable>");
1441 return ERROR_OK;
1442 }
1443
1444 int jtag_interface_init(struct command_context_s *cmd_ctx)
1445 {
1446 if (!jtag_interface)
1447 {
1448 /* nothing was previously specified by "interface" command */
1449 LOG_ERROR("JTAG interface has to be specified, see \"interface\" command");
1450 return ERROR_JTAG_INVALID_INTERFACE;
1451 }
1452
1453 if (jtag_interface->init() != ERROR_OK)
1454 return ERROR_JTAG_INIT_FAILED;
1455
1456 jtag = jtag_interface;
1457 return ERROR_OK;
1458 }
1459
1460 int jtag_init(struct command_context_s *cmd_ctx)
1461 {
1462 int validate_tries = 0;
1463 jtag_device_t *device;
1464
1465 LOG_DEBUG("-");
1466
1467 if (!jtag && jtag_interface_init(cmd_ctx) != ERROR_OK)
1468 return ERROR_JTAG_INIT_FAILED;
1469
1470 device = jtag_devices;
1471 jtag_ir_scan_size = 0;
1472 jtag_num_devices = 0;
1473 while (device != NULL)
1474 {
1475 jtag_ir_scan_size += device->ir_length;
1476 jtag_num_devices++;
1477 device = device->next;
1478 }
1479
1480 jtag_add_statemove(TAP_TLR);
1481 jtag_execute_queue();
1482
1483 /* examine chain first, as this could discover the real chain layout */
1484 if (jtag_examine_chain() != ERROR_OK)
1485 {
1486 LOG_ERROR("trying to validate configured JTAG chain anyway...");
1487 }
1488
1489 while (jtag_validate_chain() != ERROR_OK)
1490 {
1491 validate_tries++;
1492 if (validate_tries > 5)
1493 {
1494 LOG_ERROR("Could not validate JTAG chain, exit");
1495 return ERROR_JTAG_INVALID_INTERFACE;
1496 }
1497 usleep(10000);
1498 }
1499
1500 return ERROR_OK;
1501 }
1502
1503
1504 static int default_khz(int khz, int *jtag_speed)
1505 {
1506 LOG_ERROR("Translation from khz to jtag_speed not implemented");
1507 return ERROR_FAIL;
1508 }
1509
1510 int handle_interface_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1511 {
1512 int i;
1513
1514 /* check whether the interface is already configured */
1515 if (jtag_interface)
1516 {
1517 LOG_WARNING("Interface already configured, ignoring");
1518 return ERROR_OK;
1519 }
1520
1521 /* interface name is a mandatory argument */
1522 if (argc < 1 || args[0][0] == '\0')
1523 {
1524 return ERROR_COMMAND_SYNTAX_ERROR;
1525 }
1526
1527 for (i=0; jtag_interfaces[i]; i++)
1528 {
1529 if (strcmp(args[0], jtag_interfaces[i]->name) == 0)
1530 {
1531 if (jtag_interfaces[i]->register_commands(cmd_ctx) != ERROR_OK)
1532 exit(-1);
1533
1534 jtag_interface = jtag_interfaces[i];
1535
1536 if (jtag_interface->khz == NULL)
1537 {
1538 jtag_interface->khz = default_khz;
1539 }
1540 return ERROR_OK;
1541 }
1542 }
1543
1544 /* no valid interface was found (i.e. the configuration option,
1545 * didn't match one of the compiled-in interfaces
1546 */
1547 LOG_ERROR("No valid jtag interface found (%s)", args[0]);
1548 LOG_ERROR("compiled-in jtag interfaces:");
1549 for (i = 0; jtag_interfaces[i]; i++)
1550 {
1551 LOG_ERROR("%i: %s", i, jtag_interfaces[i]->name);
1552 }
1553
1554 return ERROR_JTAG_INVALID_INTERFACE;
1555 }
1556
1557 int handle_jtag_device_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1558 {
1559 jtag_device_t **last_device_p = &jtag_devices;
1560
1561 if (*last_device_p)
1562 {
1563 while ((*last_device_p)->next)
1564 last_device_p = &((*last_device_p)->next);
1565 last_device_p = &((*last_device_p)->next);
1566 }
1567
1568 if (argc < 3)
1569 return ERROR_OK;
1570
1571 *last_device_p = malloc(sizeof(jtag_device_t));
1572 (*last_device_p)->ir_length = strtoul(args[0], NULL, 0);
1573
1574 (*last_device_p)->expected = malloc((*last_device_p)->ir_length);
1575 buf_set_u32((*last_device_p)->expected, 0, (*last_device_p)->ir_length, strtoul(args[1], NULL, 0));
1576 (*last_device_p)->expected_mask = malloc((*last_device_p)->ir_length);
1577 buf_set_u32((*last_device_p)->expected_mask, 0, (*last_device_p)->ir_length, strtoul(args[2], NULL, 0));
1578
1579 (*last_device_p)->cur_instr = malloc((*last_device_p)->ir_length);
1580 (*last_device_p)->bypass = 1;
1581 buf_set_ones((*last_device_p)->cur_instr, (*last_device_p)->ir_length);
1582
1583 (*last_device_p)->next = NULL;
1584
1585 jtag_register_event_callback(jtag_reset_callback, (*last_device_p));
1586
1587 jtag_num_devices++;
1588
1589 return ERROR_OK;
1590 }
1591
1592 int handle_scan_chain_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1593 {
1594 jtag_device_t *device = jtag_devices;
1595 int device_count = 0;
1596
1597 while (device)
1598 {
1599 u32 expected, expected_mask, cur_instr;
1600 expected = buf_get_u32(device->expected, 0, device->ir_length);
1601 expected_mask = buf_get_u32(device->expected_mask, 0, device->ir_length);
1602 cur_instr = buf_get_u32(device->cur_instr, 0, device->ir_length);
1603 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);
1604 device = device->next;
1605 device_count++;
1606 }
1607
1608 return ERROR_OK;
1609 }
1610
1611 int handle_reset_config_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1612 {
1613 if (argc >= 1)
1614 {
1615 if (strcmp(args[0], "none") == 0)
1616 jtag_reset_config = RESET_NONE;
1617 else if (strcmp(args[0], "trst_only") == 0)
1618 jtag_reset_config = RESET_HAS_TRST;
1619 else if (strcmp(args[0], "srst_only") == 0)
1620 jtag_reset_config = RESET_HAS_SRST;
1621 else if (strcmp(args[0], "trst_and_srst") == 0)
1622 jtag_reset_config = RESET_TRST_AND_SRST;
1623 else
1624 {
1625 LOG_ERROR("invalid reset_config argument, defaulting to none");
1626 jtag_reset_config = RESET_NONE;
1627 return ERROR_INVALID_ARGUMENTS;
1628 }
1629 }
1630
1631 if (argc >= 2)
1632 {
1633 if (strcmp(args[1], "srst_pulls_trst") == 0)
1634 jtag_reset_config |= RESET_SRST_PULLS_TRST;
1635 else if (strcmp(args[1], "trst_pulls_srst") == 0)
1636 jtag_reset_config |= RESET_TRST_PULLS_SRST;
1637 else if (strcmp(args[1], "combined") == 0)
1638 jtag_reset_config |= RESET_SRST_PULLS_TRST | RESET_TRST_PULLS_SRST;
1639 else if (strcmp(args[1], "separate") == 0)
1640 jtag_reset_config &= ~(RESET_SRST_PULLS_TRST | RESET_TRST_PULLS_SRST);
1641 else
1642 {
1643 LOG_ERROR("invalid reset_config argument, defaulting to none");
1644 jtag_reset_config = RESET_NONE;
1645 return ERROR_INVALID_ARGUMENTS;
1646 }
1647 }
1648
1649 if (argc >= 3)
1650 {
1651 if (strcmp(args[2], "trst_open_drain") == 0)
1652 jtag_reset_config |= RESET_TRST_OPEN_DRAIN;
1653 else if (strcmp(args[2], "trst_push_pull") == 0)
1654 jtag_reset_config &= ~RESET_TRST_OPEN_DRAIN;
1655 else
1656 {
1657 LOG_ERROR("invalid reset_config argument, defaulting to none");
1658 jtag_reset_config = RESET_NONE;
1659 return ERROR_INVALID_ARGUMENTS;
1660 }
1661 }
1662
1663 if (argc >= 4)
1664 {
1665 if (strcmp(args[3], "srst_push_pull") == 0)
1666 jtag_reset_config |= RESET_SRST_PUSH_PULL;
1667 else if (strcmp(args[3], "srst_open_drain") == 0)
1668 jtag_reset_config &= ~RESET_SRST_PUSH_PULL;
1669 else
1670 {
1671 LOG_ERROR("invalid reset_config argument, defaulting to none");
1672 jtag_reset_config = RESET_NONE;
1673 return ERROR_INVALID_ARGUMENTS;
1674 }
1675 }
1676
1677 return ERROR_OK;
1678 }
1679
1680 int handle_jtag_nsrst_delay_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1681 {
1682 if (argc < 1)
1683 {
1684 LOG_ERROR("jtag_nsrst_delay <ms> command takes one required argument");
1685 exit(-1);
1686 }
1687 else
1688 {
1689 jtag_nsrst_delay = strtoul(args[0], NULL, 0);
1690 }
1691
1692 return ERROR_OK;
1693 }
1694
1695 int handle_jtag_ntrst_delay_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1696 {
1697 if (argc < 1)
1698 {
1699 LOG_ERROR("jtag_ntrst_delay <ms> command takes one required argument");
1700 exit(-1);
1701 }
1702 else
1703 {
1704 jtag_ntrst_delay = strtoul(args[0], NULL, 0);
1705 }
1706
1707 return ERROR_OK;
1708 }
1709
1710 int handle_jtag_speed_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1711 {
1712 int cur_speed = 0;
1713 if ((argc<1) || (argc>2))
1714 return ERROR_COMMAND_SYNTAX_ERROR;
1715
1716 if (argc >= 1)
1717 cur_speed = jtag_speed = jtag_speed_post_reset = strtoul(args[0], NULL, 0);
1718 if (argc == 2)
1719 cur_speed = jtag_speed_post_reset = strtoul(args[1], NULL, 0);
1720
1721 /* this command can be called during CONFIG,
1722 * in which case jtag isn't initialized */
1723 if (jtag)
1724 jtag->speed(cur_speed);
1725
1726 return ERROR_OK;
1727 }
1728
1729 int handle_jtag_khz_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1730 {
1731 int cur_speed = 0;
1732 int speed1, speed2;
1733 if ((argc<1) || (argc>2))
1734 return ERROR_COMMAND_SYNTAX_ERROR;
1735
1736 if (jtag == NULL)
1737 {
1738 LOG_ERROR("Interface not selected yet");
1739 return ERROR_COMMAND_SYNTAX_ERROR;
1740 }
1741
1742 if (argc >= 1)
1743 speed1 = strtoul(args[0], NULL, 0);
1744 if (argc == 2)
1745 speed2 = strtoul(args[1], NULL, 0);
1746
1747 if (jtag->khz(speed1, &speed1)!=ERROR_OK)
1748 return ERROR_OK;
1749
1750 if (jtag->khz(speed2, &speed2)!=ERROR_OK)
1751 return ERROR_OK;
1752
1753 if (argc >= 1)
1754 cur_speed = jtag_speed = jtag_speed_post_reset = speed1;
1755
1756 if (argc == 2)
1757 cur_speed = jtag_speed_post_reset = speed2;
1758
1759 jtag->speed(cur_speed);
1760
1761 return ERROR_OK;
1762 }
1763
1764
1765 int handle_endstate_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1766 {
1767 enum tap_state state;
1768
1769 if (argc < 1)
1770 {
1771 return ERROR_COMMAND_SYNTAX_ERROR;
1772 }
1773 else
1774 {
1775 for (state = 0; state < 16; state++)
1776 {
1777 if (strcmp(args[0], tap_state_strings[state]) == 0)
1778 {
1779 jtag_add_end_state(state);
1780 jtag_execute_queue();
1781 }
1782 }
1783 }
1784 command_print(cmd_ctx, "current endstate: %s", tap_state_strings[end_state]);
1785
1786 return ERROR_OK;
1787 }
1788
1789 int handle_jtag_reset_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1790 {
1791 int trst = -1;
1792 int srst = -1;
1793
1794 if (argc < 2)
1795 {
1796 return ERROR_COMMAND_SYNTAX_ERROR;
1797 }
1798
1799 if (args[0][0] == '1')
1800 trst = 1;
1801 else if (args[0][0] == '0')
1802 trst = 0;
1803 else
1804 {
1805 return ERROR_COMMAND_SYNTAX_ERROR;
1806 }
1807
1808 if (args[1][0] == '1')
1809 srst = 1;
1810 else if (args[1][0] == '0')
1811 srst = 0;
1812 else
1813 {
1814 return ERROR_COMMAND_SYNTAX_ERROR;
1815 }
1816
1817 if (!jtag && jtag_interface_init(cmd_ctx) != ERROR_OK)
1818 return ERROR_JTAG_INIT_FAILED;
1819
1820 jtag_add_reset(trst, srst);
1821 jtag_execute_queue();
1822
1823 return ERROR_OK;
1824 }
1825
1826 int handle_runtest_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1827 {
1828 if (argc < 1)
1829 {
1830 return ERROR_COMMAND_SYNTAX_ERROR;
1831 }
1832
1833 jtag_add_runtest(strtol(args[0], NULL, 0), -1);
1834 jtag_execute_queue();
1835
1836 return ERROR_OK;
1837
1838 }
1839
1840 int handle_statemove_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1841 {
1842 enum tap_state state;
1843
1844 state = -1;
1845 if (argc == 1)
1846 {
1847 for (state = 0; state < 16; state++)
1848 {
1849 if (strcmp(args[0], tap_state_strings[state]) == 0)
1850 {
1851 break;
1852 }
1853 }
1854 }
1855
1856 jtag_add_statemove(state);
1857 jtag_execute_queue();
1858
1859 return ERROR_OK;
1860
1861 }
1862
1863 int handle_irscan_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1864 {
1865 int i;
1866 scan_field_t *fields;
1867
1868 if ((argc < 2) || (argc % 2))
1869 {
1870 return ERROR_COMMAND_SYNTAX_ERROR;
1871 }
1872
1873 fields = malloc(sizeof(scan_field_t) * argc / 2);
1874
1875 for (i = 0; i < argc / 2; i++)
1876 {
1877 int device = strtoul(args[i*2], NULL, 0);
1878 int field_size = jtag_get_device(device)->ir_length;
1879 fields[i].device = device;
1880 fields[i].out_value = malloc(CEIL(field_size, 8));
1881 buf_set_u32(fields[i].out_value, 0, field_size, strtoul(args[i*2+1], NULL, 0));
1882 fields[i].out_mask = NULL;
1883 fields[i].in_value = NULL;
1884 fields[i].in_check_mask = NULL;
1885 fields[i].in_handler = NULL;
1886 fields[i].in_handler_priv = NULL;
1887 }
1888
1889 jtag_add_ir_scan(argc / 2, fields, -1);
1890 jtag_execute_queue();
1891
1892 for (i = 0; i < argc / 2; i++)
1893 free(fields[i].out_value);
1894
1895 free (fields);
1896
1897 return ERROR_OK;
1898 }
1899
1900 int handle_drscan_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1901 {
1902 scan_field_t *fields;
1903 int num_fields = 0;
1904 int field_count = 0;
1905 var_t *var;
1906 int i, j;
1907
1908 if ((argc < 2) || (argc % 2))
1909 {
1910 return ERROR_COMMAND_SYNTAX_ERROR;
1911 }
1912
1913 for (i = 0; i < argc; i+=2)
1914 {
1915 var = get_var_by_namenum(args[i+1]);
1916 if (var)
1917 {
1918 num_fields += var->num_fields;
1919 }
1920 else
1921 {
1922 command_print(cmd_ctx, "variable %s doesn't exist", args[i+1]);
1923 return ERROR_OK;
1924 }
1925 }
1926
1927 fields = malloc(sizeof(scan_field_t) * num_fields);
1928
1929 for (i = 0; i < argc; i+=2)
1930 {
1931 var = get_var_by_namenum(args[i+1]);
1932
1933 for (j = 0; j < var->num_fields; j++)
1934 {
1935 fields[field_count].device = strtol(args[i], NULL, 0);
1936 fields[field_count].num_bits = var->fields[j].num_bits;
1937 fields[field_count].out_value = malloc(CEIL(var->fields[j].num_bits, 8));
1938 buf_set_u32(fields[field_count].out_value, 0, var->fields[j].num_bits, var->fields[j].value);
1939 fields[field_count].out_mask = NULL;
1940 fields[field_count].in_value = fields[field_count].out_value;
1941 fields[field_count].in_check_mask = NULL;
1942 fields[field_count].in_check_value = NULL;
1943 fields[field_count].in_handler = field_le_to_host;
1944 fields[field_count++].in_handler_priv = &(var->fields[j]);
1945 }
1946 }
1947
1948 jtag_add_dr_scan(num_fields, fields, -1);
1949 jtag_execute_queue();
1950
1951 for (i = 0; i < argc / 2; i++)
1952 free(fields[i].out_value);
1953
1954 free(fields);
1955
1956 return ERROR_OK;
1957 }
1958
1959 int handle_verify_ircapture_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1960 {
1961 if (argc == 1)
1962 {
1963 if (strcmp(args[0], "enable") == 0)
1964 {
1965 jtag_verify_capture_ir = 1;
1966 }
1967 else if (strcmp(args[0], "disable") == 0)
1968 {
1969 jtag_verify_capture_ir = 0;
1970 } else
1971 {
1972 return ERROR_COMMAND_SYNTAX_ERROR;
1973 }
1974 } else if (argc != 0)
1975 {
1976 return ERROR_COMMAND_SYNTAX_ERROR;
1977 }
1978
1979 command_print(cmd_ctx, "verify Capture-IR is %s", (jtag_verify_capture_ir) ? "enabled": "disabled");
1980
1981 return ERROR_OK;
1982 }
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)