Code Review / openocd.git / blob
? search:


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