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