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