Code Review / openocd.git / blob
? search:


a27396a1df85bf345f64621e8925a0be76280d1d
[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 int 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 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 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 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 cmd_queue_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 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 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 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 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 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 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 int jtag_add_reset(int req_trst, int req_srst)
888 {
889 int trst_with_tms = 0;
890 int retval;
891
892 if (req_trst == -1)
893 req_trst = jtag_trst;
894
895 if (req_srst == -1)
896 req_srst = jtag_srst;
897
898 /* Make sure that jtag_reset_config allows the requested reset */
899 /* if SRST pulls TRST, we can't fulfill srst == 1 with trst == 0 */
900 if (((jtag_reset_config & RESET_SRST_PULLS_TRST) && (req_srst == 1)) && (req_trst == 0))
901 {
902 WARNING("requested reset would assert trst");
903 return ERROR_JTAG_RESET_WOULD_ASSERT_TRST;
904 }
905
906 /* if TRST pulls SRST, we reset with TAP T-L-R */
907 if (((jtag_reset_config & RESET_TRST_PULLS_SRST) && (req_trst == 1)) && (req_srst == 0))
908 {
909 req_trst = 0;
910 trst_with_tms = 1;
911 }
912
913 if (req_srst && !(jtag_reset_config & RESET_HAS_SRST))
914 {
915 WARNING("requested nSRST assertion, but the current configuration doesn't support this");
916 return ERROR_JTAG_RESET_CANT_SRST;
917 }
918
919 if (req_trst && !(jtag_reset_config & RESET_HAS_TRST))
920 {
921 req_trst = 0;
922 trst_with_tms = 1;
923 }
924
925 jtag_trst = req_trst;
926 jtag_srst = req_srst;
927
928 retval = interface_jtag_add_reset(req_trst, req_srst);
929 if (retval!=ERROR_OK)
930 {
931 jtag_error=retval;
932 return retval;
933 }
934
935 if (jtag_srst)
936 {
937 DEBUG("SRST line asserted");
938 }
939 else
940 {
941 DEBUG("SRST line released");
942 if (jtag_nsrst_delay)
943 jtag_add_sleep(jtag_nsrst_delay * 1000);
944 }
945
946 if (trst_with_tms)
947 {
948 DEBUG("JTAG reset with tms instead of TRST");
949 jtag_add_end_state(TAP_TLR);
950 jtag_add_statemove(TAP_TLR);
951 jtag_call_event_callbacks(JTAG_TRST_ASSERTED);
952 return ERROR_OK;
953 }
954
955 if (jtag_trst)
956 {
957 /* we just asserted nTRST, so we're now in Test-Logic-Reset,
958 * and inform possible listeners about this
959 */
960 DEBUG("TRST line asserted");
961 cmd_queue_cur_state = TAP_TLR;
962 jtag_call_event_callbacks(JTAG_TRST_ASSERTED);
963 }
964 else
965 {
966 /* the nTRST line got deasserted, so we're still in Test-Logic-Reset,
967 * but we might want to add a delay to give the TAP time to settle
968 */
969 DEBUG("Now in TAP_TLR - Test-Logic-Reset(either due to TRST line asserted or tms reset)");
970 if (jtag_ntrst_delay)
971 jtag_add_sleep(jtag_ntrst_delay * 1000);
972 }
973 return ERROR_OK;
974 }
975
976 int MINIDRIVER(interface_jtag_add_reset)(int req_trst, int req_srst)
977 {
978 jtag_command_t **last_cmd = jtag_get_last_command_p();
979
980 /* allocate memory for a new list member */
981 *last_cmd = cmd_queue_alloc(sizeof(jtag_command_t));
982 (*last_cmd)->next = NULL;
983 last_comand_pointer = &((*last_cmd)->next);
984 (*last_cmd)->type = JTAG_RESET;
985
986 (*last_cmd)->cmd.reset = cmd_queue_alloc(sizeof(reset_command_t));
987 (*last_cmd)->cmd.reset->trst = req_trst;
988 (*last_cmd)->cmd.reset->srst = req_srst;
989
990
991 return ERROR_OK;
992 }
993
994 void jtag_add_end_state(enum tap_state state)
995 {
996 cmd_queue_end_state = state;
997 }
998
999 int MINIDRIVER(interface_jtag_add_sleep)(u32 us)
1000 {
1001 jtag_command_t **last_cmd = jtag_get_last_command_p();
1002
1003 /* allocate memory for a new list member */
1004 *last_cmd = cmd_queue_alloc(sizeof(jtag_command_t));
1005 (*last_cmd)->next = NULL;
1006 last_comand_pointer = &((*last_cmd)->next);
1007 (*last_cmd)->type = JTAG_SLEEP;
1008
1009 (*last_cmd)->cmd.sleep = cmd_queue_alloc(sizeof(sleep_command_t));
1010 (*last_cmd)->cmd.sleep->us = us;
1011
1012 return ERROR_OK;
1013 }
1014
1015 void jtag_add_sleep(u32 us)
1016 {
1017 int retval=interface_jtag_add_sleep(us);
1018 if (retval!=ERROR_OK)
1019 jtag_error=retval;
1020 return;
1021 }
1022
1023 int jtag_scan_size(scan_command_t *cmd)
1024 {
1025 int bit_count = 0;
1026 int i;
1027
1028 /* count bits in scan command */
1029 for (i = 0; i < cmd->num_fields; i++)
1030 {
1031 bit_count += cmd->fields[i].num_bits;
1032 }
1033
1034 return bit_count;
1035 }
1036
1037 int jtag_build_buffer(scan_command_t *cmd, u8 **buffer)
1038 {
1039 int bit_count = 0;
1040 int i;
1041
1042 bit_count = jtag_scan_size(cmd);
1043 *buffer = malloc(CEIL(bit_count, 8));
1044
1045 bit_count = 0;
1046
1047 for (i = 0; i < cmd->num_fields; i++)
1048 {
1049 if (cmd->fields[i].out_value)
1050 {
1051 #ifdef _DEBUG_JTAG_IO_
1052 char* char_buf = buf_to_str(cmd->fields[i].out_value, (cmd->fields[i].num_bits > 64) ? 64 : cmd->fields[i].num_bits, 16);
1053 #endif
1054 buf_set_buf(cmd->fields[i].out_value, 0, *buffer, bit_count, cmd->fields[i].num_bits);
1055 #ifdef _DEBUG_JTAG_IO_
1056 DEBUG("fields[%i].out_value: 0x%s", i, char_buf);
1057 free(char_buf);
1058 #endif
1059 }
1060
1061 bit_count += cmd->fields[i].num_bits;
1062 }
1063
1064 return bit_count;
1065
1066 }
1067
1068 int jtag_read_buffer(u8 *buffer, scan_command_t *cmd)
1069 {
1070 int i;
1071 int bit_count = 0;
1072 int retval;
1073
1074 /* we return ERROR_OK, unless a check fails, or a handler reports a problem */
1075 retval = ERROR_OK;
1076
1077 for (i = 0; i < cmd->num_fields; i++)
1078 {
1079 /* if neither in_value nor in_handler
1080 * are specified we don't have to examine this field
1081 */
1082 if (cmd->fields[i].in_value || cmd->fields[i].in_handler)
1083 {
1084 int num_bits = cmd->fields[i].num_bits;
1085 u8 *captured = buf_set_buf(buffer, bit_count, malloc(CEIL(num_bits, 8)), 0, num_bits);
1086
1087 #ifdef _DEBUG_JTAG_IO_
1088 char *char_buf;
1089
1090 char_buf = buf_to_str(captured, (num_bits > 64) ? 64 : num_bits, 16);
1091 DEBUG("fields[%i].in_value: 0x%s", i, char_buf);
1092 free(char_buf);
1093 #endif
1094
1095 if (cmd->fields[i].in_value)
1096 {
1097 buf_cpy(captured, cmd->fields[i].in_value, num_bits);
1098
1099 if (cmd->fields[i].in_handler)
1100 {
1101 if (cmd->fields[i].in_handler(cmd->fields[i].in_value, cmd->fields[i].in_handler_priv, cmd->fields+i) != ERROR_OK)
1102 {
1103 WARNING("in_handler reported a failed check");
1104 retval = ERROR_JTAG_QUEUE_FAILED;
1105 }
1106 }
1107 }
1108
1109 /* no in_value specified, but a handler takes care of the scanned data */
1110 if (cmd->fields[i].in_handler && (!cmd->fields[i].in_value))
1111 {
1112 if (cmd->fields[i].in_handler(captured, cmd->fields[i].in_handler_priv, cmd->fields+i) != ERROR_OK)
1113 {
1114 /* We're going to call the error:handler later, but if the in_handler
1115 * reported an error we report this failure upstream
1116 */
1117 WARNING("in_handler reported a failed check");
1118 retval = ERROR_JTAG_QUEUE_FAILED;
1119 }
1120 }
1121
1122 free(captured);
1123 }
1124 bit_count += cmd->fields[i].num_bits;
1125 }
1126
1127 return retval;
1128 }
1129
1130 int jtag_check_value(u8 *captured, void *priv, scan_field_t *field)
1131 {
1132 int retval = ERROR_OK;
1133 int num_bits = field->num_bits;
1134
1135 int compare_failed = 0;
1136
1137 if (field->in_check_mask)
1138 compare_failed = buf_cmp_mask(captured, field->in_check_value, field->in_check_mask, num_bits);
1139 else
1140 compare_failed = buf_cmp(captured, field->in_check_value, num_bits);
1141
1142 if (compare_failed)
1143 {
1144 /* An error handler could have caught the failing check
1145 * only report a problem when there wasn't a handler, or if the handler
1146 * acknowledged the error
1147 */
1148 if (compare_failed)
1149 {
1150 char *captured_char = buf_to_str(captured, (num_bits > 64) ? 64 : num_bits, 16);
1151 char *in_check_value_char = buf_to_str(field->in_check_value, (num_bits > 64) ? 64 : num_bits, 16);
1152
1153 if (field->in_check_mask)
1154 {
1155 char *in_check_mask_char;
1156 in_check_mask_char = buf_to_str(field->in_check_mask, (num_bits > 64) ? 64 : num_bits, 16);
1157 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);
1158 free(in_check_mask_char);
1159 }
1160 else
1161 {
1162 WARNING("value captured during scan didn't pass the requested check: captured: 0x%s check_value: 0x%s", captured_char, in_check_value_char);
1163 }
1164
1165 free(captured_char);
1166 free(in_check_value_char);
1167
1168 retval = ERROR_JTAG_QUEUE_FAILED;
1169 }
1170
1171 }
1172 return retval;
1173 }
1174
1175 /*
1176 set up checking of this field using the in_handler. The values passed in must be valid until
1177 after jtag_execute() has completed.
1178 */
1179 void jtag_set_check_value(scan_field_t *field, u8 *value, u8 *mask, error_handler_t *in_error_handler)
1180 {
1181 if (value)
1182 field->in_handler = jtag_check_value;
1183 else
1184 field->in_handler = NULL; /* No check, e.g. embeddedice uses value==NULL to indicate no check */
1185 field->in_handler_priv = NULL; /* this will be filled in at the invocation site to point to the field duplicate */
1186 field->in_check_value = value;
1187 field->in_check_mask = mask;
1188 }
1189
1190 enum scan_type jtag_scan_type(scan_command_t *cmd)
1191 {
1192 int i;
1193 int type = 0;
1194
1195 for (i = 0; i < cmd->num_fields; i++)
1196 {
1197 if (cmd->fields[i].in_value || cmd->fields[i].in_handler)
1198 type |= SCAN_IN;
1199 if (cmd->fields[i].out_value)
1200 type |= SCAN_OUT;
1201 }
1202
1203 return type;
1204 }
1205
1206 int MINIDRIVER(interface_jtag_execute_queue)(void)
1207 {
1208 int retval;
1209
1210 retval = jtag->execute_queue();
1211
1212 cmd_queue_free();
1213
1214 jtag_command_queue = NULL;
1215 last_comand_pointer = &jtag_command_queue;
1216
1217 return retval;
1218 }
1219
1220 int jtag_execute_queue(void)
1221 {
1222 int retval=interface_jtag_execute_queue();
1223 if (retval==ERROR_OK)
1224 {
1225 retval=jtag_error;
1226 }
1227 jtag_error=ERROR_OK;
1228 return retval;
1229 }
1230
1231 int jtag_reset_callback(enum jtag_event event, void *priv)
1232 {
1233 jtag_device_t *device = priv;
1234
1235 DEBUG("-");
1236
1237 if (event == JTAG_TRST_ASSERTED)
1238 {
1239 buf_set_ones(device->cur_instr, device->ir_length);
1240 device->bypass = 1;
1241 }
1242
1243 return ERROR_OK;
1244 }
1245
1246 void jtag_sleep(u32 us)
1247 {
1248 usleep(us);
1249 }
1250
1251 /* Try to examine chain layout according to IEEE 1149.1 §12
1252 */
1253 int jtag_examine_chain()
1254 {
1255 jtag_device_t *device = jtag_devices;
1256 scan_field_t field;
1257 u8 idcode_buffer[JTAG_MAX_CHAIN_SIZE * 4];
1258 int i;
1259 int bit_count;
1260 int device_count = 0;
1261 u8 zero_check = 0x0;
1262 u8 one_check = 0xff;
1263
1264 field.device = 0;
1265 field.num_bits = sizeof(idcode_buffer) * 8;
1266 field.out_value = idcode_buffer;
1267 field.out_mask = NULL;
1268 field.in_value = idcode_buffer;
1269 field.in_check_value = NULL;
1270 field.in_check_mask = NULL;
1271 field.in_handler = NULL;
1272 field.in_handler_priv = NULL;
1273
1274 for (i = 0; i < JTAG_MAX_CHAIN_SIZE; i++)
1275 {
1276 buf_set_u32(idcode_buffer, i * 32, 32, 0x000000FF);
1277 }
1278
1279 jtag_add_plain_dr_scan(1, &field, TAP_TLR);
1280 jtag_execute_queue();
1281
1282 for (i = 0; i < JTAG_MAX_CHAIN_SIZE * 4; i++)
1283 {
1284 zero_check |= idcode_buffer[i];
1285 one_check &= idcode_buffer[i];
1286 }
1287
1288 /* if there wasn't a single non-zero bit or if all bits were one, the scan isn't valid */
1289 if ((zero_check == 0x00) || (one_check == 0xff))
1290 {
1291 ERROR("JTAG communication failure, check connection, JTAG interface, target power etc.");
1292 return ERROR_JTAG_INIT_FAILED;
1293 }
1294
1295 for (bit_count = 0; bit_count < (JTAG_MAX_CHAIN_SIZE * 32) - 31;)
1296 {
1297 u32 idcode = buf_get_u32(idcode_buffer, bit_count, 32);
1298 if ((idcode & 1) == 0)
1299 {
1300 /* LSB must not be 0, this indicates a device in bypass */
1301 device_count++;
1302
1303 bit_count += 1;
1304 }
1305 else
1306 {
1307 u32 manufacturer;
1308 u32 part;
1309 u32 version;
1310
1311 if (idcode == 0x000000FF)
1312 {
1313 /* End of chain (invalid manufacturer ID) */
1314 break;
1315 }
1316
1317 if (device)
1318 {
1319 device->idcode = idcode;
1320 device = device->next;
1321 }
1322 device_count++;
1323
1324 manufacturer = (idcode & 0xffe) >> 1;
1325 part = (idcode & 0xffff000) >> 12;
1326 version = (idcode & 0xf0000000) >> 28;
1327
1328 INFO("JTAG device found: 0x%8.8x (Manufacturer: 0x%3.3x, Part: 0x%4.4x, Version: 0x%1.1x)",
1329 idcode, manufacturer, part, version);
1330
1331 bit_count += 32;
1332 }
1333 }
1334
1335 /* see if number of discovered devices matches configuration */
1336 if (device_count != jtag_num_devices)
1337 {
1338 ERROR("number of discovered devices in JTAG chain (%i) doesn't match configuration (%i)",
1339 device_count, jtag_num_devices);
1340 ERROR("check the config file and ensure proper JTAG communication (connections, speed, ...)");
1341 return ERROR_JTAG_INIT_FAILED;
1342 }
1343
1344 return ERROR_OK;
1345 }
1346
1347 int jtag_validate_chain()
1348 {
1349 jtag_device_t *device = jtag_devices;
1350 int total_ir_length = 0;
1351 u8 *ir_test = NULL;
1352 scan_field_t field;
1353 int chain_pos = 0;
1354
1355 while (device)
1356 {
1357 total_ir_length += device->ir_length;
1358 device = device->next;
1359 }
1360
1361 total_ir_length += 2;
1362 ir_test = malloc(CEIL(total_ir_length, 8));
1363 buf_set_ones(ir_test, total_ir_length);
1364
1365 field.device = 0;
1366 field.num_bits = total_ir_length;
1367 field.out_value = ir_test;
1368 field.out_mask = NULL;
1369 field.in_value = ir_test;
1370 field.in_check_value = NULL;
1371 field.in_check_mask = NULL;
1372 field.in_handler = NULL;
1373 field.in_handler_priv = NULL;
1374
1375 jtag_add_plain_ir_scan(1, &field, TAP_TLR);
1376 jtag_execute_queue();
1377
1378 device = jtag_devices;
1379 while (device)
1380 {
1381 if (buf_get_u32(ir_test, chain_pos, 2) != 0x1)
1382 {
1383 char *cbuf = buf_to_str(ir_test, total_ir_length, 16);
1384 ERROR("Error validating JTAG scan chain, IR mismatch, scan returned 0x%s", cbuf);
1385 free(cbuf);
1386 free(ir_test);
1387 return ERROR_JTAG_INIT_FAILED;
1388 }
1389 chain_pos += device->ir_length;
1390 device = device->next;
1391 }
1392
1393 if (buf_get_u32(ir_test, chain_pos, 2) != 0x3)
1394 {
1395 char *cbuf = buf_to_str(ir_test, total_ir_length, 16);
1396 ERROR("Error validating JTAG scan chain, IR mismatch, scan returned 0x%s", cbuf);
1397 free(cbuf);
1398 free(ir_test);
1399 return ERROR_JTAG_INIT_FAILED;
1400 }
1401
1402 free(ir_test);
1403
1404 return ERROR_OK;
1405 }
1406
1407 int jtag_register_commands(struct command_context_s *cmd_ctx)
1408 {
1409 register_command(cmd_ctx, NULL, "interface", handle_interface_command,
1410 COMMAND_CONFIG, NULL);
1411 register_command(cmd_ctx, NULL, "jtag_speed", handle_jtag_speed_command,
1412 COMMAND_ANY, "set jtag speed (if supported) <reset speed> [<post reset speed, default value is reset speed>]");
1413 register_command(cmd_ctx, NULL, "jtag_khz", handle_jtag_khz_command,
1414 COMMAND_ANY, "same as jtag_speed, except it takes maximum khz as arguments. 0 KHz = RTCK.");
1415 register_command(cmd_ctx, NULL, "jtag_device", handle_jtag_device_command,
1416 COMMAND_CONFIG, "jtag_device <ir_length> <ir_expected> <ir_mask>");
1417 register_command(cmd_ctx, NULL, "reset_config", handle_reset_config_command,
1418 COMMAND_CONFIG, NULL);
1419 register_command(cmd_ctx, NULL, "jtag_nsrst_delay", handle_jtag_nsrst_delay_command,
1420 COMMAND_CONFIG, NULL);
1421 register_command(cmd_ctx, NULL, "jtag_ntrst_delay", handle_jtag_ntrst_delay_command,
1422 COMMAND_CONFIG, NULL);
1423
1424 register_command(cmd_ctx, NULL, "scan_chain", handle_scan_chain_command,
1425 COMMAND_EXEC, "print current scan chain configuration");
1426
1427 register_command(cmd_ctx, NULL, "endstate", handle_endstate_command,
1428 COMMAND_EXEC, "finish JTAG operations in <tap_state>");
1429 register_command(cmd_ctx, NULL, "jtag_reset", handle_jtag_reset_command,
1430 COMMAND_EXEC, "toggle reset lines <trst> <srst>");
1431 register_command(cmd_ctx, NULL, "runtest", handle_runtest_command,
1432 COMMAND_EXEC, "move to Run-Test/Idle, and execute <num_cycles>");
1433 register_command(cmd_ctx, NULL, "statemove", handle_statemove_command,
1434 COMMAND_EXEC, "move to current endstate or [tap_state]");
1435 register_command(cmd_ctx, NULL, "irscan", handle_irscan_command,
1436 COMMAND_EXEC, "execute IR scan <device> <instr> [dev2] [instr2] ...");
1437 register_command(cmd_ctx, NULL, "drscan", handle_drscan_command,
1438 COMMAND_EXEC, "execute DR scan <device> <var> [dev2] [var2] ...");
1439
1440 register_command(cmd_ctx, NULL, "verify_ircapture", handle_verify_ircapture_command,
1441 COMMAND_ANY, "verify value captured during Capture-IR <enable|disable>");
1442 return ERROR_OK;
1443 }
1444
1445 int jtag_interface_init(struct command_context_s *cmd_ctx)
1446 {
1447 if (!jtag_interface)
1448 {
1449 /* nothing was previously specified by "interface" command */
1450 ERROR("JTAG interface has to be specified, see \"interface\" command");
1451 return ERROR_JTAG_INVALID_INTERFACE;
1452 }
1453
1454 if (jtag_interface->init() != ERROR_OK)
1455 return ERROR_JTAG_INIT_FAILED;
1456
1457 jtag = jtag_interface;
1458 return ERROR_OK;
1459 }
1460
1461 int jtag_init(struct command_context_s *cmd_ctx)
1462 {
1463 int validate_tries = 0;
1464 jtag_device_t *device;
1465
1466 DEBUG("-");
1467
1468 if (!jtag && jtag_interface_init(cmd_ctx) != ERROR_OK)
1469 return ERROR_JTAG_INIT_FAILED;
1470
1471 device = jtag_devices;
1472 jtag_ir_scan_size = 0;
1473 jtag_num_devices = 0;
1474 while (device != NULL)
1475 {
1476 jtag_ir_scan_size += device->ir_length;
1477 jtag_num_devices++;
1478 device = device->next;
1479 }
1480
1481 jtag_add_statemove(TAP_TLR);
1482 jtag_execute_queue();
1483
1484 /* examine chain first, as this could discover the real chain layout */
1485 if (jtag_examine_chain() != ERROR_OK)
1486 {
1487 ERROR("trying to validate configured JTAG chain anyway...");
1488 }
1489
1490 while (jtag_validate_chain() != ERROR_OK)
1491 {
1492 validate_tries++;
1493 if (validate_tries > 5)
1494 {
1495 ERROR("Could not validate JTAG chain, exit");
1496 return ERROR_JTAG_INVALID_INTERFACE;
1497 }
1498 usleep(10000);
1499 }
1500
1501 return ERROR_OK;
1502 }
1503
1504
1505 static int default_khz(int khz, int *jtag_speed)
1506 {
1507 ERROR("Translation from khz to jtag_speed not implemented");
1508 return ERROR_FAIL;
1509 }
1510
1511 int handle_interface_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1512 {
1513 int i;
1514
1515 /* check whether the interface is already configured */
1516 if (jtag_interface)
1517 {
1518 WARNING("Interface already configured, ignoring");
1519 return ERROR_OK;
1520 }
1521
1522 /* interface name is a mandatory argument */
1523 if (argc < 1 || args[0][0] == '\0')
1524 {
1525 return ERROR_COMMAND_SYNTAX_ERROR;
1526 }
1527
1528 for (i=0; jtag_interfaces[i]; i++)
1529 {
1530 if (strcmp(args[0], jtag_interfaces[i]->name) == 0)
1531 {
1532 if (jtag_interfaces[i]->register_commands(cmd_ctx) != ERROR_OK)
1533 exit(-1);
1534
1535 jtag_interface = jtag_interfaces[i];
1536
1537 if (jtag_interface->khz == NULL)
1538 {
1539 jtag_interface->khz = default_khz;
1540 }
1541 return ERROR_OK;
1542 }
1543 }
1544
1545 /* no valid interface was found (i.e. the configuration option,
1546 * didn't match one of the compiled-in interfaces
1547 */
1548 ERROR("No valid jtag interface found (%s)", args[0]);
1549 ERROR("compiled-in jtag interfaces:");
1550 for (i = 0; jtag_interfaces[i]; i++)
1551 {
1552 ERROR("%i: %s", i, jtag_interfaces[i]->name);
1553 }
1554
1555 return ERROR_JTAG_INVALID_INTERFACE;
1556 }
1557
1558 int handle_jtag_device_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1559 {
1560 jtag_device_t **last_device_p = &jtag_devices;
1561
1562 if (*last_device_p)
1563 {
1564 while ((*last_device_p)->next)
1565 last_device_p = &((*last_device_p)->next);
1566 last_device_p = &((*last_device_p)->next);
1567 }
1568
1569 if (argc < 3)
1570 return ERROR_OK;
1571
1572 *last_device_p = malloc(sizeof(jtag_device_t));
1573 (*last_device_p)->ir_length = strtoul(args[0], NULL, 0);
1574
1575 (*last_device_p)->expected = malloc((*last_device_p)->ir_length);
1576 buf_set_u32((*last_device_p)->expected, 0, (*last_device_p)->ir_length, strtoul(args[1], NULL, 0));
1577 (*last_device_p)->expected_mask = malloc((*last_device_p)->ir_length);
1578 buf_set_u32((*last_device_p)->expected_mask, 0, (*last_device_p)->ir_length, strtoul(args[2], NULL, 0));
1579
1580 (*last_device_p)->cur_instr = malloc((*last_device_p)->ir_length);
1581 (*last_device_p)->bypass = 1;
1582 buf_set_ones((*last_device_p)->cur_instr, (*last_device_p)->ir_length);
1583
1584 (*last_device_p)->next = NULL;
1585
1586 jtag_register_event_callback(jtag_reset_callback, (*last_device_p));
1587
1588 jtag_num_devices++;
1589
1590 return ERROR_OK;
1591 }
1592
1593 int handle_scan_chain_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1594 {
1595 jtag_device_t *device = jtag_devices;
1596 int device_count = 0;
1597
1598 while (device)
1599 {
1600 u32 expected, expected_mask, cur_instr;
1601 expected = buf_get_u32(device->expected, 0, device->ir_length);
1602 expected_mask = buf_get_u32(device->expected_mask, 0, device->ir_length);
1603 cur_instr = buf_get_u32(device->cur_instr, 0, device->ir_length);
1604 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);
1605 device = device->next;
1606 device_count++;
1607 }
1608
1609 return ERROR_OK;
1610 }
1611
1612 int handle_reset_config_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1613 {
1614 if (argc >= 1)
1615 {
1616 if (strcmp(args[0], "none") == 0)
1617 jtag_reset_config = RESET_NONE;
1618 else if (strcmp(args[0], "trst_only") == 0)
1619 jtag_reset_config = RESET_HAS_TRST;
1620 else if (strcmp(args[0], "srst_only") == 0)
1621 jtag_reset_config = RESET_HAS_SRST;
1622 else if (strcmp(args[0], "trst_and_srst") == 0)
1623 jtag_reset_config = RESET_TRST_AND_SRST;
1624 else
1625 {
1626 ERROR("invalid reset_config argument, defaulting to none");
1627 jtag_reset_config = RESET_NONE;
1628 return ERROR_INVALID_ARGUMENTS;
1629 }
1630 }
1631
1632 if (argc >= 2)
1633 {
1634 if (strcmp(args[1], "srst_pulls_trst") == 0)
1635 jtag_reset_config |= RESET_SRST_PULLS_TRST;
1636 else if (strcmp(args[1], "trst_pulls_srst") == 0)
1637 jtag_reset_config |= RESET_TRST_PULLS_SRST;
1638 else if (strcmp(args[1], "combined") == 0)
1639 jtag_reset_config |= RESET_SRST_PULLS_TRST | RESET_TRST_PULLS_SRST;
1640 else if (strcmp(args[1], "separate") == 0)
1641 jtag_reset_config &= ~(RESET_SRST_PULLS_TRST | RESET_TRST_PULLS_SRST);
1642 else
1643 {
1644 ERROR("invalid reset_config argument, defaulting to none");
1645 jtag_reset_config = RESET_NONE;
1646 return ERROR_INVALID_ARGUMENTS;
1647 }
1648 }
1649
1650 if (argc >= 3)
1651 {
1652 if (strcmp(args[2], "trst_open_drain") == 0)
1653 jtag_reset_config |= RESET_TRST_OPEN_DRAIN;
1654 else if (strcmp(args[2], "trst_push_pull") == 0)
1655 jtag_reset_config &= ~RESET_TRST_OPEN_DRAIN;
1656 else
1657 {
1658 ERROR("invalid reset_config argument, defaulting to none");
1659 jtag_reset_config = RESET_NONE;
1660 return ERROR_INVALID_ARGUMENTS;
1661 }
1662 }
1663
1664 if (argc >= 4)
1665 {
1666 if (strcmp(args[3], "srst_push_pull") == 0)
1667 jtag_reset_config |= RESET_SRST_PUSH_PULL;
1668 else if (strcmp(args[3], "srst_open_drain") == 0)
1669 jtag_reset_config &= ~RESET_SRST_PUSH_PULL;
1670 else
1671 {
1672 ERROR("invalid reset_config argument, defaulting to none");
1673 jtag_reset_config = RESET_NONE;
1674 return ERROR_INVALID_ARGUMENTS;
1675 }
1676 }
1677
1678 return ERROR_OK;
1679 }
1680
1681 int handle_jtag_nsrst_delay_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1682 {
1683 if (argc < 1)
1684 {
1685 ERROR("jtag_nsrst_delay <ms> command takes one required argument");
1686 exit(-1);
1687 }
1688 else
1689 {
1690 jtag_nsrst_delay = strtoul(args[0], NULL, 0);
1691 }
1692
1693 return ERROR_OK;
1694 }
1695
1696 int handle_jtag_ntrst_delay_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1697 {
1698 if (argc < 1)
1699 {
1700 ERROR("jtag_ntrst_delay <ms> command takes one required argument");
1701 exit(-1);
1702 }
1703 else
1704 {
1705 jtag_ntrst_delay = strtoul(args[0], NULL, 0);
1706 }
1707
1708 return ERROR_OK;
1709 }
1710
1711 int handle_jtag_speed_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1712 {
1713 int cur_speed = 0;
1714 if ((argc<1) || (argc>2))
1715 return ERROR_COMMAND_SYNTAX_ERROR;
1716
1717 if (argc >= 1)
1718 cur_speed = jtag_speed = jtag_speed_post_reset = strtoul(args[0], NULL, 0);
1719 if (argc == 2)
1720 cur_speed = jtag_speed_post_reset = strtoul(args[1], NULL, 0);
1721
1722 /* this command can be called during CONFIG,
1723 * in which case jtag isn't initialized */
1724 if (jtag)
1725 jtag->speed(cur_speed);
1726
1727 return ERROR_OK;
1728 }
1729
1730 int handle_jtag_khz_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1731 {
1732 int cur_speed = 0;
1733 int speed1, speed2;
1734 if ((argc<1) || (argc>2))
1735 return ERROR_COMMAND_SYNTAX_ERROR;
1736
1737 if (jtag == NULL)
1738 {
1739 ERROR("Interface not selected yet");
1740 return ERROR_COMMAND_SYNTAX_ERROR;
1741 }
1742
1743 if (argc >= 1)
1744 speed1 = strtoul(args[0], NULL, 0);
1745 if (argc == 2)
1746 speed2 = strtoul(args[1], NULL, 0);
1747
1748 if (jtag->khz(speed1, &speed1)!=ERROR_OK)
1749 return ERROR_OK;
1750
1751 if (jtag->khz(speed2, &speed2)!=ERROR_OK)
1752 return ERROR_OK;
1753
1754 if (argc >= 1)
1755 cur_speed = jtag_speed = jtag_speed_post_reset = speed1;
1756
1757 if (argc == 2)
1758 cur_speed = jtag_speed_post_reset = speed2;
1759
1760 jtag->speed(cur_speed);
1761
1762 return ERROR_OK;
1763 }
1764
1765
1766 int handle_endstate_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1767 {
1768 enum tap_state state;
1769
1770 if (argc < 1)
1771 {
1772 return ERROR_COMMAND_SYNTAX_ERROR;
1773 }
1774 else
1775 {
1776 for (state = 0; state < 16; state++)
1777 {
1778 if (strcmp(args[0], tap_state_strings[state]) == 0)
1779 {
1780 jtag_add_end_state(state);
1781 jtag_execute_queue();
1782 }
1783 }
1784 }
1785 command_print(cmd_ctx, "current endstate: %s", tap_state_strings[end_state]);
1786
1787 return ERROR_OK;
1788 }
1789
1790 int handle_jtag_reset_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1791 {
1792 int trst = -1;
1793 int srst = -1;
1794
1795 if (argc < 2)
1796 {
1797 return ERROR_COMMAND_SYNTAX_ERROR;
1798 }
1799
1800 if (args[0][0] == '1')
1801 trst = 1;
1802 else if (args[0][0] == '0')
1803 trst = 0;
1804 else
1805 {
1806 return ERROR_COMMAND_SYNTAX_ERROR;
1807 }
1808
1809 if (args[1][0] == '1')
1810 srst = 1;
1811 else if (args[1][0] == '0')
1812 srst = 0;
1813 else
1814 {
1815 return ERROR_COMMAND_SYNTAX_ERROR;
1816 }
1817
1818 if (!jtag && jtag_interface_init(cmd_ctx) != ERROR_OK)
1819 return ERROR_JTAG_INIT_FAILED;
1820
1821 jtag_add_reset(trst, srst);
1822 jtag_execute_queue();
1823
1824 return ERROR_OK;
1825 }
1826
1827 int handle_runtest_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1828 {
1829 if (argc < 1)
1830 {
1831 return ERROR_COMMAND_SYNTAX_ERROR;
1832 }
1833
1834 jtag_add_runtest(strtol(args[0], NULL, 0), -1);
1835 jtag_execute_queue();
1836
1837 return ERROR_OK;
1838
1839 }
1840
1841 int handle_statemove_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1842 {
1843 enum tap_state state;
1844
1845 state = -1;
1846 if (argc == 1)
1847 {
1848 for (state = 0; state < 16; state++)
1849 {
1850 if (strcmp(args[0], tap_state_strings[state]) == 0)
1851 {
1852 break;
1853 }
1854 }
1855 }
1856
1857 jtag_add_statemove(state);
1858 jtag_execute_queue();
1859
1860 return ERROR_OK;
1861
1862 }
1863
1864 int handle_irscan_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1865 {
1866 int i;
1867 scan_field_t *fields;
1868
1869 if ((argc < 2) || (argc % 2))
1870 {
1871 return ERROR_COMMAND_SYNTAX_ERROR;
1872 }
1873
1874 fields = malloc(sizeof(scan_field_t) * argc / 2);
1875
1876 for (i = 0; i < argc / 2; i++)
1877 {
1878 int device = strtoul(args[i*2], NULL, 0);
1879 int field_size = jtag_get_device(device)->ir_length;
1880 fields[i].device = device;
1881 fields[i].out_value = malloc(CEIL(field_size, 8));
1882 buf_set_u32(fields[i].out_value, 0, field_size, strtoul(args[i*2+1], NULL, 0));
1883 fields[i].out_mask = NULL;
1884 fields[i].in_value = NULL;
1885 fields[i].in_check_mask = NULL;
1886 fields[i].in_handler = NULL;
1887 fields[i].in_handler_priv = NULL;
1888 }
1889
1890 jtag_add_ir_scan(argc / 2, fields, -1);
1891 jtag_execute_queue();
1892
1893 for (i = 0; i < argc / 2; i++)
1894 free(fields[i].out_value);
1895
1896 free (fields);
1897
1898 return ERROR_OK;
1899 }
1900
1901 int handle_drscan_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1902 {
1903 scan_field_t *fields;
1904 int num_fields = 0;
1905 int field_count = 0;
1906 var_t *var;
1907 int i, j;
1908
1909 if ((argc < 2) || (argc % 2))
1910 {
1911 return ERROR_COMMAND_SYNTAX_ERROR;
1912 }
1913
1914 for (i = 0; i < argc; i+=2)
1915 {
1916 var = get_var_by_namenum(args[i+1]);
1917 if (var)
1918 {
1919 num_fields += var->num_fields;
1920 }
1921 else
1922 {
1923 command_print(cmd_ctx, "variable %s doesn't exist", args[i+1]);
1924 return ERROR_OK;
1925 }
1926 }
1927
1928 fields = malloc(sizeof(scan_field_t) * num_fields);
1929
1930 for (i = 0; i < argc; i+=2)
1931 {
1932 var = get_var_by_namenum(args[i+1]);
1933
1934 for (j = 0; j < var->num_fields; j++)
1935 {
1936 fields[field_count].device = strtol(args[i], NULL, 0);
1937 fields[field_count].num_bits = var->fields[j].num_bits;
1938 fields[field_count].out_value = malloc(CEIL(var->fields[j].num_bits, 8));
1939 buf_set_u32(fields[field_count].out_value, 0, var->fields[j].num_bits, var->fields[j].value);
1940 fields[field_count].out_mask = NULL;
1941 fields[field_count].in_value = fields[field_count].out_value;
1942 fields[field_count].in_check_mask = NULL;
1943 fields[field_count].in_check_value = NULL;
1944 fields[field_count].in_handler = field_le_to_host;
1945 fields[field_count++].in_handler_priv = &(var->fields[j]);
1946 }
1947 }
1948
1949 jtag_add_dr_scan(num_fields, fields, -1);
1950 jtag_execute_queue();
1951
1952 for (i = 0; i < argc / 2; i++)
1953 free(fields[i].out_value);
1954
1955 free(fields);
1956
1957 return ERROR_OK;
1958 }
1959
1960 int handle_verify_ircapture_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1961 {
1962 if (argc == 1)
1963 {
1964 if (strcmp(args[0], "enable") == 0)
1965 {
1966 jtag_verify_capture_ir = 1;
1967 }
1968 else if (strcmp(args[0], "disable") == 0)
1969 {
1970 jtag_verify_capture_ir = 0;
1971 } else
1972 {
1973 return ERROR_COMMAND_SYNTAX_ERROR;
1974 }
1975 } else if (argc != 0)
1976 {
1977 return ERROR_COMMAND_SYNTAX_ERROR;
1978 }
1979
1980 command_print(cmd_ctx, "verify Capture-IR is %s", (jtag_verify_capture_ir) ? "enabled": "disabled");
1981
1982 return ERROR_OK;
1983 }
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)