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