Code Review / openocd.git / blob
? search:


b39e58645fd31cfafff05cee930c64ee391e51fe
[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 speed1 = 0, speed2 = 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 int jtag_speed_post_reset = 0;
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) <reset speed> [<post reset speed, default value is reset speed>]");
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 /*stay on "reset speed"*/
1514 jtag_interface->khz(speed1, &jtag_speed);
1515 jtag_interface->khz(speed2, &jtag_speed_post_reset);
1516 hasKHz = 0;
1517 }
1518
1519 if (jtag_interface->init() != ERROR_OK)
1520 return ERROR_JTAG_INIT_FAILED;
1521
1522
1523
1524 jtag = jtag_interface;
1525 return ERROR_OK;
1526 }
1527
1528 static int jtag_init_inner(struct command_context_s *cmd_ctx)
1529 {
1530 int validate_tries = 0;
1531 jtag_device_t *device;
1532 int retval;
1533
1534 LOG_DEBUG("Init JTAG chain");
1535
1536 device = jtag_devices;
1537 jtag_ir_scan_size = 0;
1538 jtag_num_devices = 0;
1539 while (device != NULL)
1540 {
1541 jtag_ir_scan_size += device->ir_length;
1542 jtag_num_devices++;
1543 device = device->next;
1544 }
1545
1546 jtag_add_tlr();
1547 if ((retval=jtag_execute_queue())!=ERROR_OK)
1548 return retval;
1549
1550 /* examine chain first, as this could discover the real chain layout */
1551 if (jtag_examine_chain() != ERROR_OK)
1552 {
1553 LOG_ERROR("trying to validate configured JTAG chain anyway...");
1554 }
1555
1556 while (jtag_validate_chain() != ERROR_OK)
1557 {
1558 validate_tries++;
1559
1560 if (validate_tries > 5)
1561 {
1562 LOG_ERROR("Could not validate JTAG chain, exit");
1563 return ERROR_JTAG_INVALID_INTERFACE;
1564 }
1565 usleep(10000);
1566 }
1567
1568 return ERROR_OK;
1569 }
1570
1571 int jtag_init_reset(struct command_context_s *cmd_ctx)
1572 {
1573 int retval;
1574
1575 if ((retval=jtag_interface_init(cmd_ctx)) != ERROR_OK)
1576 return retval;
1577
1578 LOG_DEBUG("Trying to bring the JTAG controller to life by asserting TRST / TLR");
1579
1580 /* Reset can happen after a power cycle.
1581 *
1582 * Ideally we would only assert TRST or run TLR before the target reset.
1583 *
1584 * However w/srst_pulls_trst, trst is asserted together with the target
1585 * reset whether we want it or not.
1586 *
1587 * NB! Some targets have JTAG circuitry disabled until a
1588 * trst & srst has been asserted.
1589 *
1590 * NB! here we assume nsrst/ntrst delay are sufficient!
1591 *
1592 * NB! order matters!!!! srst *can* disconnect JTAG circuitry
1593 *
1594 */
1595 jtag_add_reset(1, 0); /* TLR or TRST */
1596 if (jtag_reset_config & RESET_HAS_SRST)
1597 {
1598 jtag_add_reset(1, 1);
1599 if ((jtag_reset_config & RESET_SRST_PULLS_TRST)==0)
1600 jtag_add_reset(0, 1);
1601 }
1602 jtag_add_reset(0, 0);
1603 if ((retval = jtag_execute_queue()) != ERROR_OK)
1604 return retval;
1605
1606 /* Check that we can communication on the JTAG chain + eventually we want to
1607 * be able to perform enumeration only after OpenOCD has started
1608 * telnet and GDB server
1609 *
1610 * That would allow users to more easily perform any magic they need to before
1611 * reset happens.
1612 */
1613 return jtag_init_inner(cmd_ctx);
1614 }
1615
1616 int jtag_init(struct command_context_s *cmd_ctx)
1617 {
1618 int retval;
1619 if ((retval=jtag_interface_init(cmd_ctx)) != ERROR_OK)
1620 return retval;
1621 if (jtag_init_inner(cmd_ctx)==ERROR_OK)
1622 {
1623 return ERROR_OK;
1624 }
1625 return jtag_init_reset(cmd_ctx);
1626 }
1627
1628 static int default_khz(int khz, int *jtag_speed)
1629 {
1630 LOG_ERROR("Translation from khz to jtag_speed not implemented");
1631 return ERROR_FAIL;
1632 }
1633
1634 static int default_speed_div(int speed, int *khz)
1635 {
1636 return ERROR_FAIL;
1637 }
1638
1639 int handle_interface_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1640 {
1641 int i;
1642
1643 /* check whether the interface is already configured */
1644 if (jtag_interface)
1645 {
1646 LOG_WARNING("Interface already configured, ignoring");
1647 return ERROR_OK;
1648 }
1649
1650 /* interface name is a mandatory argument */
1651 if (argc < 1 || args[0][0] == '\0')
1652 {
1653 return ERROR_COMMAND_SYNTAX_ERROR;
1654 }
1655
1656 for (i=0; jtag_interfaces[i]; i++)
1657 {
1658 if (strcmp(args[0], jtag_interfaces[i]->name) == 0)
1659 {
1660 if (jtag_interfaces[i]->register_commands(cmd_ctx) != ERROR_OK)
1661 exit(-1);
1662
1663 jtag_interface = jtag_interfaces[i];
1664
1665 if (jtag_interface->khz == NULL)
1666 {
1667 jtag_interface->khz = default_khz;
1668 }
1669 if (jtag_interface->speed_div == NULL)
1670 {
1671 jtag_interface->speed_div = default_speed_div;
1672 }
1673 return ERROR_OK;
1674 }
1675 }
1676
1677 /* no valid interface was found (i.e. the configuration option,
1678 * didn't match one of the compiled-in interfaces
1679 */
1680 LOG_ERROR("No valid jtag interface found (%s)", args[0]);
1681 LOG_ERROR("compiled-in jtag interfaces:");
1682 for (i = 0; jtag_interfaces[i]; i++)
1683 {
1684 LOG_ERROR("%i: %s", i, jtag_interfaces[i]->name);
1685 }
1686
1687 return ERROR_JTAG_INVALID_INTERFACE;
1688 }
1689
1690 int handle_jtag_device_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1691 {
1692 jtag_device_t **last_device_p = &jtag_devices;
1693
1694 if (*last_device_p)
1695 {
1696 while ((*last_device_p)->next)
1697 last_device_p = &((*last_device_p)->next);
1698 last_device_p = &((*last_device_p)->next);
1699 }
1700
1701 if (argc < 3)
1702 return ERROR_OK;
1703
1704 *last_device_p = malloc(sizeof(jtag_device_t));
1705 (*last_device_p)->ir_length = strtoul(args[0], NULL, 0);
1706
1707 (*last_device_p)->expected = malloc((*last_device_p)->ir_length);
1708 buf_set_u32((*last_device_p)->expected, 0, (*last_device_p)->ir_length, strtoul(args[1], NULL, 0));
1709 (*last_device_p)->expected_mask = malloc((*last_device_p)->ir_length);
1710 buf_set_u32((*last_device_p)->expected_mask, 0, (*last_device_p)->ir_length, strtoul(args[2], NULL, 0));
1711
1712 (*last_device_p)->cur_instr = malloc((*last_device_p)->ir_length);
1713 (*last_device_p)->bypass = 1;
1714 buf_set_ones((*last_device_p)->cur_instr, (*last_device_p)->ir_length);
1715
1716 (*last_device_p)->next = NULL;
1717
1718 jtag_register_event_callback(jtag_reset_callback, (*last_device_p));
1719
1720 jtag_num_devices++;
1721
1722 return ERROR_OK;
1723 }
1724
1725 int handle_scan_chain_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1726 {
1727 jtag_device_t *device = jtag_devices;
1728 int device_count = 0;
1729
1730 while (device)
1731 {
1732 u32 expected, expected_mask, cur_instr;
1733 expected = buf_get_u32(device->expected, 0, device->ir_length);
1734 expected_mask = buf_get_u32(device->expected_mask, 0, device->ir_length);
1735 cur_instr = buf_get_u32(device->cur_instr, 0, device->ir_length);
1736 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);
1737 device = device->next;
1738 device_count++;
1739 }
1740
1741 return ERROR_OK;
1742 }
1743
1744 int handle_reset_config_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1745 {
1746 if (argc < 1)
1747 return ERROR_COMMAND_SYNTAX_ERROR;
1748
1749 if (argc >= 1)
1750 {
1751 if (strcmp(args[0], "none") == 0)
1752 jtag_reset_config = RESET_NONE;
1753 else if (strcmp(args[0], "trst_only") == 0)
1754 jtag_reset_config = RESET_HAS_TRST;
1755 else if (strcmp(args[0], "srst_only") == 0)
1756 jtag_reset_config = RESET_HAS_SRST;
1757 else if (strcmp(args[0], "trst_and_srst") == 0)
1758 jtag_reset_config = RESET_TRST_AND_SRST;
1759 else
1760 {
1761 LOG_ERROR("invalid reset_config argument, defaulting to none");
1762 jtag_reset_config = RESET_NONE;
1763 return ERROR_INVALID_ARGUMENTS;
1764 }
1765 }
1766
1767 if (argc >= 2)
1768 {
1769 if (strcmp(args[1], "separate") == 0)
1770 {
1771 /* seperate reset lines - default */
1772 } else
1773 {
1774 if (strcmp(args[1], "srst_pulls_trst") == 0)
1775 jtag_reset_config |= RESET_SRST_PULLS_TRST;
1776 else if (strcmp(args[1], "trst_pulls_srst") == 0)
1777 jtag_reset_config |= RESET_TRST_PULLS_SRST;
1778 else if (strcmp(args[1], "combined") == 0)
1779 jtag_reset_config |= RESET_SRST_PULLS_TRST | RESET_TRST_PULLS_SRST;
1780 else
1781 {
1782 LOG_ERROR("invalid reset_config argument, defaulting to none");
1783 jtag_reset_config = RESET_NONE;
1784 return ERROR_INVALID_ARGUMENTS;
1785 }
1786 }
1787 }
1788
1789 if (argc >= 3)
1790 {
1791 if (strcmp(args[2], "trst_open_drain") == 0)
1792 jtag_reset_config |= RESET_TRST_OPEN_DRAIN;
1793 else if (strcmp(args[2], "trst_push_pull") == 0)
1794 jtag_reset_config &= ~RESET_TRST_OPEN_DRAIN;
1795 else
1796 {
1797 LOG_ERROR("invalid reset_config argument, defaulting to none");
1798 jtag_reset_config = RESET_NONE;
1799 return ERROR_INVALID_ARGUMENTS;
1800 }
1801 }
1802
1803 if (argc >= 4)
1804 {
1805 if (strcmp(args[3], "srst_push_pull") == 0)
1806 jtag_reset_config |= RESET_SRST_PUSH_PULL;
1807 else if (strcmp(args[3], "srst_open_drain") == 0)
1808 jtag_reset_config &= ~RESET_SRST_PUSH_PULL;
1809 else
1810 {
1811 LOG_ERROR("invalid reset_config argument, defaulting to none");
1812 jtag_reset_config = RESET_NONE;
1813 return ERROR_INVALID_ARGUMENTS;
1814 }
1815 }
1816
1817 return ERROR_OK;
1818 }
1819
1820 int handle_jtag_nsrst_delay_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1821 {
1822 if (argc < 1)
1823 {
1824 LOG_ERROR("jtag_nsrst_delay <ms> command takes one required argument");
1825 exit(-1);
1826 }
1827 else
1828 {
1829 jtag_nsrst_delay = strtoul(args[0], NULL, 0);
1830 }
1831
1832 return ERROR_OK;
1833 }
1834
1835 int handle_jtag_ntrst_delay_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1836 {
1837 if (argc < 1)
1838 {
1839 LOG_ERROR("jtag_ntrst_delay <ms> command takes one required argument");
1840 exit(-1);
1841 }
1842 else
1843 {
1844 jtag_ntrst_delay = strtoul(args[0], NULL, 0);
1845 }
1846
1847 return ERROR_OK;
1848 }
1849
1850 int handle_jtag_speed_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1851 {
1852 int cur_speed = 0;
1853
1854 if (argc != 0)
1855 {
1856 if ((argc<1) || (argc>2))
1857 return ERROR_COMMAND_SYNTAX_ERROR;
1858
1859 LOG_DEBUG("handle jtag speed");
1860
1861 if (argc >= 1)
1862 cur_speed = jtag_speed = jtag_speed_post_reset = strtoul(args[0], NULL, 0);
1863 if (argc == 2)
1864 cur_speed = jtag_speed_post_reset = strtoul(args[1], NULL, 0);
1865
1866 /* this command can be called during CONFIG,
1867 * in which case jtag isn't initialized */
1868 if (jtag)
1869 {
1870 jtag->speed_div(jtag_speed, &speed1);
1871 jtag->speed_div(jtag_speed_post_reset, &speed2);
1872 jtag->speed(cur_speed);
1873 }
1874 }
1875 command_print(cmd_ctx, "jtag_speed: %d, %d", jtag_speed, jtag_speed_post_reset);
1876
1877 return ERROR_OK;
1878 }
1879
1880 int handle_jtag_khz_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1881 {
1882 LOG_DEBUG("handle jtag khz");
1883
1884 if (argc>2)
1885 return ERROR_COMMAND_SYNTAX_ERROR;
1886
1887 if(argc != 0)
1888 {
1889
1890 if (argc >= 1)
1891 speed1 = speed2 = strtoul(args[0], NULL, 0);
1892 if (argc == 2)
1893 speed2 = strtoul(args[1], NULL, 0);
1894
1895 if (jtag != NULL)
1896 {
1897 int cur_speed = 0;
1898 LOG_DEBUG("have interface set up");
1899 int speed_div1, speed_div2;
1900 if (jtag->khz(speed1, &speed_div1)!=ERROR_OK)
1901 {
1902 speed1 = speed2 = 0;
1903 return ERROR_OK;
1904 }
1905 if (jtag->khz(speed2, &speed_div2)!=ERROR_OK)
1906 {
1907 speed1 = speed2 = 0;
1908 return ERROR_OK;
1909 }
1910
1911 if (argc >= 1)
1912 cur_speed = jtag_speed = jtag_speed_post_reset = speed_div1;
1913 if (argc == 2)
1914 cur_speed = jtag_speed_post_reset = speed_div2;
1915
1916 jtag->speed(cur_speed);
1917 } else
1918 {
1919 hasKHz = 1;
1920 }
1921 }
1922 command_print(cmd_ctx, "jtag_khz: %d, %d", speed1, speed2);
1923
1924 return ERROR_OK;
1925 }
1926
1927 int handle_endstate_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1928 {
1929 enum tap_state state;
1930
1931 if (argc < 1)
1932 {
1933 return ERROR_COMMAND_SYNTAX_ERROR;
1934 }
1935 else
1936 {
1937 for (state = 0; state < 16; state++)
1938 {
1939 if (strcmp(args[0], tap_state_strings[state]) == 0)
1940 {
1941 jtag_add_end_state(state);
1942 jtag_execute_queue();
1943 }
1944 }
1945 }
1946 command_print(cmd_ctx, "current endstate: %s", tap_state_strings[cmd_queue_end_state]);
1947
1948 return ERROR_OK;
1949 }
1950
1951 int handle_jtag_reset_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1952 {
1953 int trst = -1;
1954 int srst = -1;
1955
1956 if (argc < 2)
1957 {
1958 return ERROR_COMMAND_SYNTAX_ERROR;
1959 }
1960
1961 if (args[0][0] == '1')
1962 trst = 1;
1963 else if (args[0][0] == '0')
1964 trst = 0;
1965 else
1966 {
1967 return ERROR_COMMAND_SYNTAX_ERROR;
1968 }
1969
1970 if (args[1][0] == '1')
1971 srst = 1;
1972 else if (args[1][0] == '0')
1973 srst = 0;
1974 else
1975 {
1976 return ERROR_COMMAND_SYNTAX_ERROR;
1977 }
1978
1979 if (jtag_interface_init(cmd_ctx) != ERROR_OK)
1980 return ERROR_JTAG_INIT_FAILED;
1981
1982 jtag_add_reset(trst, srst);
1983 jtag_execute_queue();
1984
1985 return ERROR_OK;
1986 }
1987
1988 int handle_runtest_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1989 {
1990 if (argc < 1)
1991 {
1992 return ERROR_COMMAND_SYNTAX_ERROR;
1993 }
1994
1995 jtag_add_runtest(strtol(args[0], NULL, 0), -1);
1996 jtag_execute_queue();
1997
1998 return ERROR_OK;
1999
2000 }
2001
2002 int handle_irscan_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2003 {
2004 int i;
2005 scan_field_t *fields;
2006
2007 if ((argc < 2) || (argc % 2))
2008 {
2009 return ERROR_COMMAND_SYNTAX_ERROR;
2010 }
2011
2012 fields = malloc(sizeof(scan_field_t) * argc / 2);
2013
2014 for (i = 0; i < argc / 2; i++)
2015 {
2016 int device = strtoul(args[i*2], NULL, 0);
2017 int field_size = jtag_get_device(device)->ir_length;
2018 fields[i].device = device;
2019 fields[i].out_value = malloc(CEIL(field_size, 8));
2020 buf_set_u32(fields[i].out_value, 0, field_size, strtoul(args[i*2+1], NULL, 0));
2021 fields[i].out_mask = NULL;
2022 fields[i].in_value = NULL;
2023 fields[i].in_check_mask = NULL;
2024 fields[i].in_handler = NULL;
2025 fields[i].in_handler_priv = NULL;
2026 }
2027
2028 jtag_add_ir_scan(argc / 2, fields, -1);
2029 jtag_execute_queue();
2030
2031 for (i = 0; i < argc / 2; i++)
2032 free(fields[i].out_value);
2033
2034 free (fields);
2035
2036 return ERROR_OK;
2037 }
2038
2039 int Jim_Command_drscan(Jim_Interp *interp, int argc, Jim_Obj *const *args)
2040 {
2041 int retval;
2042 scan_field_t *fields;
2043 int num_fields;
2044 int field_count = 0;
2045 int i, e;
2046 long device;
2047
2048 /* args[1] = device
2049 * args[2] = num_bits
2050 * args[3] = hex string
2051 * ... repeat num bits and hex string ...
2052 */
2053 if ((argc < 4) || ((argc % 2)!=0))
2054 {
2055 Jim_WrongNumArgs(interp, 1, args, "wrong arguments");
2056 return JIM_ERR;
2057 }
2058
2059 for (i = 2; i < argc; i+=2)
2060 {
2061 long bits;
2062
2063 e = Jim_GetLong(interp, args[i], &bits);
2064 if (e != JIM_OK)
2065 return e;
2066 }
2067
2068 e = Jim_GetLong(interp, args[1], &device);
2069 if (e != JIM_OK)
2070 return e;
2071
2072 num_fields=(argc-2)/2;
2073 fields = malloc(sizeof(scan_field_t) * num_fields);
2074 for (i = 2; i < argc; i+=2)
2075 {
2076 long bits;
2077 int len;
2078 const char *str;
2079
2080 Jim_GetLong(interp, args[i], &bits);
2081 str = Jim_GetString(args[i+1], &len);
2082
2083 fields[field_count].device = device;
2084 fields[field_count].num_bits = bits;
2085 fields[field_count].out_value = malloc(CEIL(bits, 8));
2086 str_to_buf(str, len, fields[field_count].out_value, bits, 0);
2087 fields[field_count].out_mask = NULL;
2088 fields[field_count].in_value = fields[field_count].out_value;
2089 fields[field_count].in_check_mask = NULL;
2090 fields[field_count].in_check_value = NULL;
2091 fields[field_count].in_handler = NULL;
2092 fields[field_count++].in_handler_priv = NULL;
2093 }
2094
2095 jtag_add_dr_scan(num_fields, fields, -1);
2096 retval = jtag_execute_queue();
2097 if (retval != ERROR_OK)
2098 {
2099 Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
2100 Jim_AppendStrings(interp, Jim_GetResult(interp), "drscan: jtag execute failed", NULL);
2101 return JIM_ERR;
2102 }
2103
2104 field_count=0;
2105 Jim_Obj *list = Jim_NewListObj(interp, NULL, 0);
2106 for (i = 2; i < argc; i+=2)
2107 {
2108 long bits;
2109 char *str;
2110
2111 Jim_GetLong(interp, args[i], &bits);
2112 str = buf_to_str(fields[field_count].in_value, bits, 16);
2113 free(fields[field_count].out_value);
2114
2115 Jim_ListAppendElement(interp, list, Jim_NewStringObj(interp, str, strlen(str)));
2116 free(str);
2117 field_count++;
2118 }
2119
2120 Jim_SetResult(interp, list);
2121
2122 free(fields);
2123
2124 return JIM_OK;
2125 }
2126
2127 int handle_verify_ircapture_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2128 {
2129 if (argc == 1)
2130 {
2131 if (strcmp(args[0], "enable") == 0)
2132 {
2133 jtag_verify_capture_ir = 1;
2134 }
2135 else if (strcmp(args[0], "disable") == 0)
2136 {
2137 jtag_verify_capture_ir = 0;
2138 } else
2139 {
2140 return ERROR_COMMAND_SYNTAX_ERROR;
2141 }
2142 } else if (argc != 0)
2143 {
2144 return ERROR_COMMAND_SYNTAX_ERROR;
2145 }
2146
2147 command_print(cmd_ctx, "verify Capture-IR is %s", (jtag_verify_capture_ir) ? "enabled": "disabled");
2148
2149 return ERROR_OK;
2150 }
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)